src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm

/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP

#import <Foundation/Foundation.h>

#import "MTRAttributeCacheContainer_Internal.h"
#import "MTRBaseDevice_internal.h"
#import "MTRCallbackBridge_internal.h"
#import "MTRClusterConstants.h"
#import "MTRCluster_internal.h"
#import "MTRClusters_internal.h"
#import "MTRCommandPayloadsObjc.h"
#import "MTRDevice.h"
#import "MTRDevice_Internal.h"
#import "MTRStructsObjc.h"

#include <lib/support/CHIPListUtils.h>
#include <platform/CHIPDeviceLayer.h>
#include <type_traits>

using chip::Callback::Callback;
using chip::Callback::Cancelable;
using namespace chip::app::Clusters;
using chip::Messaging::ExchangeManager;
using chip::SessionHandle;

// NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks): Linter is unable to locate the delete on these objects.
@implementation MTRClusterIdentify

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)identifyWithParams:(MTRIdentifyClusterIdentifyParams *)params
            expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
         completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)triggerEffectWithParams:(MTRIdentifyClusterTriggerEffectParams *)params
                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeIdentifyTimeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIdentifyID)
                                        attributeId:@(MTRClusterIdentifyAttributeIdentifyTimeID)
                                             params:params];
}

- (void)writeAttributeIdentifyTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeIdentifyTimeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeIdentifyTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterIdentifyID)
                                  attributeId:@(MTRClusterIdentifyAttributeIdentifyTimeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeIdentifyTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIdentifyID)
                                        attributeId:@(MTRClusterIdentifyAttributeIdentifyTypeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIdentifyID)
                                        attributeId:@(MTRClusterIdentifyAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIdentifyID)
                                        attributeId:@(MTRClusterIdentifyAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIdentifyID)
                                        attributeId:@(MTRClusterIdentifyAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIdentifyID)
                                        attributeId:@(MTRClusterIdentifyAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIdentifyID)
                                        attributeId:@(MTRClusterIdentifyAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterGroups

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)addGroupWithParams:(MTRGroupsClusterAddGroupParams *)params
            expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
         completionHandler:
             (void (^)(MTRGroupsClusterAddGroupResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)viewGroupWithParams:(MTRGroupsClusterViewGroupParams *)params
             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
          completionHandler:
              (void (^)(MTRGroupsClusterViewGroupResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)getGroupMembershipWithParams:(MTRGroupsClusterGetGroupMembershipParams *)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(void (^)(MTRGroupsClusterGetGroupMembershipResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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.
                                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();
                    }
                }

                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];
}

- (void)removeGroupWithParams:(MTRGroupsClusterRemoveGroupParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:
                (void (^)(MTRGroupsClusterRemoveGroupResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)removeAllGroupsWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                        completionHandler:(StatusCompletion)completionHandler
{
    [self removeAllGroupsWithParams:nil
                     expectedValues:expectedValues
              expectedValueInterval:expectedValueIntervalMs
                  completionHandler:completionHandler];
}
- (void)removeAllGroupsWithParams:(MTRGroupsClusterRemoveAllGroupsParams * _Nullable)params
                   expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)addGroupIfIdentifyingWithParams:(MTRGroupsClusterAddGroupIfIdentifyingParams *)params
                         expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                      completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeNameSupportWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupsID)
                                        attributeId:@(MTRClusterGroupsAttributeNameSupportID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupsID)
                                        attributeId:@(MTRClusterGroupsAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupsID)
                                        attributeId:@(MTRClusterGroupsAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupsID)
                                        attributeId:@(MTRClusterGroupsAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupsID)
                                        attributeId:@(MTRClusterGroupsAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupsID)
                                        attributeId:@(MTRClusterGroupsAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterScenes

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)addSceneWithParams:(MTRScenesClusterAddSceneParams *)params
            expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
         completionHandler:
             (void (^)(MTRScenesClusterAddSceneResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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.
                                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.
                                            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.
                                                        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_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();
                    }
                }

                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];
}

- (void)viewSceneWithParams:(MTRScenesClusterViewSceneParams *)params
             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
          completionHandler:
              (void (^)(MTRScenesClusterViewSceneResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)removeSceneWithParams:(MTRScenesClusterRemoveSceneParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:
                (void (^)(MTRScenesClusterRemoveSceneResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)removeAllScenesWithParams:(MTRScenesClusterRemoveAllScenesParams *)params
                   expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                completionHandler:(void (^)(MTRScenesClusterRemoveAllScenesResponseParams * _Nullable data,
                                      NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)storeSceneWithParams:(MTRScenesClusterStoreSceneParams *)params
              expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
           completionHandler:
               (void (^)(MTRScenesClusterStoreSceneResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)recallSceneWithParams:(MTRScenesClusterRecallSceneParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                    }
                }

                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];
}

- (void)getSceneMembershipWithParams:(MTRScenesClusterGetSceneMembershipParams *)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(void (^)(MTRScenesClusterGetSceneMembershipResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)enhancedAddSceneWithParams:(MTRScenesClusterEnhancedAddSceneParams *)params
                    expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                 completionHandler:(void (^)(MTRScenesClusterEnhancedAddSceneResponseParams * _Nullable data,
                                       NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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.
                                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.
                                            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.
                                                        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_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();
                    }
                }

                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];
}

- (void)enhancedViewSceneWithParams:(MTRScenesClusterEnhancedViewSceneParams *)params
                     expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                  completionHandler:(void (^)(MTRScenesClusterEnhancedViewSceneResponseParams * _Nullable data,
                                        NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)copySceneWithParams:(MTRScenesClusterCopySceneParams *)params
             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
          completionHandler:
              (void (^)(MTRScenesClusterCopySceneResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeSceneCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterScenesID)
                                        attributeId:@(MTRClusterScenesAttributeSceneCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentSceneWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterScenesID)
                                        attributeId:@(MTRClusterScenesAttributeCurrentSceneID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentGroupWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterScenesID)
                                        attributeId:@(MTRClusterScenesAttributeCurrentGroupID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSceneValidWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterScenesID)
                                        attributeId:@(MTRClusterScenesAttributeSceneValidID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNameSupportWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterScenesID)
                                        attributeId:@(MTRClusterScenesAttributeNameSupportID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLastConfiguredByWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterScenesID)
                                        attributeId:@(MTRClusterScenesAttributeLastConfiguredByID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterScenesID)
                                        attributeId:@(MTRClusterScenesAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterScenesID)
                                        attributeId:@(MTRClusterScenesAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterScenesID)
                                        attributeId:@(MTRClusterScenesAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterScenesID)
                                        attributeId:@(MTRClusterScenesAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterScenesID)
                                        attributeId:@(MTRClusterScenesAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterOnOff

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)offWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    [self offWithParams:nil
               expectedValues:expectedValues
        expectedValueInterval:expectedValueIntervalMs
            completionHandler:completionHandler];
}
- (void)offWithParams:(MTROnOffClusterOffParams * _Nullable)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)onWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
           completionHandler:(StatusCompletion)completionHandler
{
    [self onWithParams:nil
               expectedValues:expectedValues
        expectedValueInterval:expectedValueIntervalMs
            completionHandler:completionHandler];
}
- (void)onWithParams:(MTROnOffClusterOnParams * _Nullable)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)toggleWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
               completionHandler:(StatusCompletion)completionHandler
{
    [self toggleWithParams:nil
               expectedValues:expectedValues
        expectedValueInterval:expectedValueIntervalMs
            completionHandler:completionHandler];
}
- (void)toggleWithParams:(MTROnOffClusterToggleParams * _Nullable)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)offWithEffectWithParams:(MTROnOffClusterOffWithEffectParams *)params
                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)onWithRecallGlobalSceneWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                completionHandler:(StatusCompletion)completionHandler
{
    [self onWithRecallGlobalSceneWithParams:nil
                             expectedValues:expectedValues
                      expectedValueInterval:expectedValueIntervalMs
                          completionHandler:completionHandler];
}
- (void)onWithRecallGlobalSceneWithParams:(MTROnOffClusterOnWithRecallGlobalSceneParams * _Nullable)params
                           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)onWithTimedOffWithParams:(MTROnOffClusterOnWithTimedOffParams *)params
                  expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
               completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeOnOffWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffID)
                                        attributeId:@(MTRClusterOnOffAttributeOnOffID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGlobalSceneControlWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffID)
                                        attributeId:@(MTRClusterOnOffAttributeGlobalSceneControlID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOnTimeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffID)
                                        attributeId:@(MTRClusterOnOffAttributeOnTimeID)
                                             params:params];
}

- (void)writeAttributeOnTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOnTimeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOnTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOnOffID)
                                  attributeId:@(MTRClusterOnOffAttributeOnTimeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOffWaitTimeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffID)
                                        attributeId:@(MTRClusterOnOffAttributeOffWaitTimeID)
                                             params:params];
}

- (void)writeAttributeOffWaitTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOffWaitTimeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOffWaitTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOnOffID)
                                  attributeId:@(MTRClusterOnOffAttributeOffWaitTimeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeStartUpOnOffWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffID)
                                        attributeId:@(MTRClusterOnOffAttributeStartUpOnOffID)
                                             params:params];
}

- (void)writeAttributeStartUpOnOffWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeStartUpOnOffWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeStartUpOnOffWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOnOffID)
                                  attributeId:@(MTRClusterOnOffAttributeStartUpOnOffID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffID)
                                        attributeId:@(MTRClusterOnOffAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffID)
                                        attributeId:@(MTRClusterOnOffAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffID)
                                        attributeId:@(MTRClusterOnOffAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffID)
                                        attributeId:@(MTRClusterOnOffAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffID)
                                        attributeId:@(MTRClusterOnOffAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterOnOffSwitchConfiguration

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeSwitchTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffSwitchConfigurationID)
                                        attributeId:@(MTRClusterOnOffSwitchConfigurationAttributeSwitchTypeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSwitchActionsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffSwitchConfigurationID)
                                        attributeId:@(MTRClusterOnOffSwitchConfigurationAttributeSwitchActionsID)
                                             params:params];
}

- (void)writeAttributeSwitchActionsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeSwitchActionsWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeSwitchActionsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOnOffSwitchConfigurationID)
                                  attributeId:@(MTRClusterOnOffSwitchConfigurationAttributeSwitchActionsID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffSwitchConfigurationID)
                                        attributeId:@(MTRClusterOnOffSwitchConfigurationAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffSwitchConfigurationID)
                                        attributeId:@(MTRClusterOnOffSwitchConfigurationAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffSwitchConfigurationID)
                                        attributeId:@(MTRClusterOnOffSwitchConfigurationAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffSwitchConfigurationID)
                                        attributeId:@(MTRClusterOnOffSwitchConfigurationAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOnOffSwitchConfigurationID)
                                        attributeId:@(MTRClusterOnOffSwitchConfigurationAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterLevelControl

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)moveToLevelWithParams:(MTRLevelControlClusterMoveToLevelParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)moveWithParams:(MTRLevelControlClusterMoveParams *)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)stepWithParams:(MTRLevelControlClusterStepParams *)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)stopWithParams:(MTRLevelControlClusterStopParams *)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)moveToLevelWithOnOffWithParams:(MTRLevelControlClusterMoveToLevelWithOnOffParams *)params
                        expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                     completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)moveWithOnOffWithParams:(MTRLevelControlClusterMoveWithOnOffParams *)params
                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)stepWithOnOffWithParams:(MTRLevelControlClusterStepWithOnOffParams *)params
                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)stopWithOnOffWithParams:(MTRLevelControlClusterStopWithOnOffParams *)params
                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)moveToClosestFrequencyWithParams:(MTRLevelControlClusterMoveToClosestFrequencyParams *)params
                          expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                       completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentLevelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeCurrentLevelID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRemainingTimeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeRemainingTimeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinLevelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeMinLevelID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxLevelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeMaxLevelID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentFrequencyWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeCurrentFrequencyID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinFrequencyWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeMinFrequencyID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxFrequencyWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeMaxFrequencyID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOptionsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeOptionsID)
                                             params:params];
}

- (void)writeAttributeOptionsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOptionsWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOptionsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterLevelControlID)
                                  attributeId:@(MTRClusterLevelControlAttributeOptionsID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOnOffTransitionTimeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeOnOffTransitionTimeID)
                                             params:params];
}

- (void)writeAttributeOnOffTransitionTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOnOffTransitionTimeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOnOffTransitionTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterLevelControlID)
                                  attributeId:@(MTRClusterLevelControlAttributeOnOffTransitionTimeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOnLevelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeOnLevelID)
                                             params:params];
}

- (void)writeAttributeOnLevelWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOnLevelWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOnLevelWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterLevelControlID)
                                  attributeId:@(MTRClusterLevelControlAttributeOnLevelID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOnTransitionTimeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeOnTransitionTimeID)
                                             params:params];
}

- (void)writeAttributeOnTransitionTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOnTransitionTimeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOnTransitionTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                         params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterLevelControlID)
                                  attributeId:@(MTRClusterLevelControlAttributeOnTransitionTimeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOffTransitionTimeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeOffTransitionTimeID)
                                             params:params];
}

- (void)writeAttributeOffTransitionTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOffTransitionTimeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOffTransitionTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                          params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterLevelControlID)
                                  attributeId:@(MTRClusterLevelControlAttributeOffTransitionTimeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeDefaultMoveRateWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeDefaultMoveRateID)
                                             params:params];
}

- (void)writeAttributeDefaultMoveRateWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeDefaultMoveRateWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeDefaultMoveRateWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                        params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterLevelControlID)
                                  attributeId:@(MTRClusterLevelControlAttributeDefaultMoveRateID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeStartUpCurrentLevelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeStartUpCurrentLevelID)
                                             params:params];
}

- (void)writeAttributeStartUpCurrentLevelWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeStartUpCurrentLevelWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeStartUpCurrentLevelWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterLevelControlID)
                                  attributeId:@(MTRClusterLevelControlAttributeStartUpCurrentLevelID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLevelControlID)
                                        attributeId:@(MTRClusterLevelControlAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterBinaryInputBasic

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeActiveTextWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributeActiveTextID)
                                             params:params];
}

- (void)writeAttributeActiveTextWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeActiveTextWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeActiveTextWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                   params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBinaryInputBasicID)
                                  attributeId:@(MTRClusterBinaryInputBasicAttributeActiveTextID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeDescriptionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributeDescriptionID)
                                             params:params];
}

- (void)writeAttributeDescriptionWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeDescriptionWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeDescriptionWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBinaryInputBasicID)
                                  attributeId:@(MTRClusterBinaryInputBasicAttributeDescriptionID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInactiveTextWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributeInactiveTextID)
                                             params:params];
}

- (void)writeAttributeInactiveTextWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInactiveTextWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInactiveTextWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBinaryInputBasicID)
                                  attributeId:@(MTRClusterBinaryInputBasicAttributeInactiveTextID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOutOfServiceWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributeOutOfServiceID)
                                             params:params];
}

- (void)writeAttributeOutOfServiceWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOutOfServiceWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOutOfServiceWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBinaryInputBasicID)
                                  attributeId:@(MTRClusterBinaryInputBasicAttributeOutOfServiceID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributePolarityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributePolarityID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePresentValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributePresentValueID)
                                             params:params];
}

- (void)writeAttributePresentValueWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributePresentValueWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributePresentValueWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBinaryInputBasicID)
                                  attributeId:@(MTRClusterBinaryInputBasicAttributePresentValueID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeReliabilityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributeReliabilityID)
                                             params:params];
}

- (void)writeAttributeReliabilityWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeReliabilityWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeReliabilityWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBinaryInputBasicID)
                                  attributeId:@(MTRClusterBinaryInputBasicAttributeReliabilityID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeStatusFlagsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributeStatusFlagsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeApplicationTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributeApplicationTypeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBinaryInputBasicID)
                                        attributeId:@(MTRClusterBinaryInputBasicAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterDescriptor

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeDeviceListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDescriptorID)
                                        attributeId:@(MTRClusterDescriptorAttributeDeviceListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeServerListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDescriptorID)
                                        attributeId:@(MTRClusterDescriptorAttributeServerListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClientListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDescriptorID)
                                        attributeId:@(MTRClusterDescriptorAttributeClientListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePartsListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDescriptorID)
                                        attributeId:@(MTRClusterDescriptorAttributePartsListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDescriptorID)
                                        attributeId:@(MTRClusterDescriptorAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDescriptorID)
                                        attributeId:@(MTRClusterDescriptorAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDescriptorID)
                                        attributeId:@(MTRClusterDescriptorAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDescriptorID)
                                        attributeId:@(MTRClusterDescriptorAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDescriptorID)
                                        attributeId:@(MTRClusterDescriptorAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterBinding

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeBindingWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBindingID)
                                        attributeId:@(MTRClusterBindingAttributeBindingID)
                                             params:params];
}

- (void)writeAttributeBindingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBindingWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeBindingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBindingID)
                                  attributeId:@(MTRClusterBindingAttributeBindingID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBindingID)
                                        attributeId:@(MTRClusterBindingAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBindingID)
                                        attributeId:@(MTRClusterBindingAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBindingID)
                                        attributeId:@(MTRClusterBindingAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBindingID)
                                        attributeId:@(MTRClusterBindingAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBindingID)
                                        attributeId:@(MTRClusterBindingAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterAccessControl

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeAclWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccessControlID)
                                        attributeId:@(MTRClusterAccessControlAttributeAclID)
                                             params:params];
}

- (void)writeAttributeAclWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeAclWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeAclWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterAccessControlID)
                                  attributeId:@(MTRClusterAccessControlAttributeAclID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeExtensionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccessControlID)
                                        attributeId:@(MTRClusterAccessControlAttributeExtensionID)
                                             params:params];
}

- (void)writeAttributeExtensionWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeExtensionWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeExtensionWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                  params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterAccessControlID)
                                  attributeId:@(MTRClusterAccessControlAttributeExtensionID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeSubjectsPerAccessControlEntryWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccessControlID)
                                        attributeId:@(MTRClusterAccessControlAttributeSubjectsPerAccessControlEntryID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTargetsPerAccessControlEntryWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccessControlID)
                                        attributeId:@(MTRClusterAccessControlAttributeTargetsPerAccessControlEntryID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAccessControlEntriesPerFabricWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccessControlID)
                                        attributeId:@(MTRClusterAccessControlAttributeAccessControlEntriesPerFabricID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccessControlID)
                                        attributeId:@(MTRClusterAccessControlAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccessControlID)
                                        attributeId:@(MTRClusterAccessControlAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccessControlID)
                                        attributeId:@(MTRClusterAccessControlAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccessControlID)
                                        attributeId:@(MTRClusterAccessControlAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccessControlID)
                                        attributeId:@(MTRClusterAccessControlAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterBridgedActions

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)instantActionWithParams:(MTRBridgedActionsClusterInstantActionParams *)params
                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                BridgedActions::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::BridgedActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.InvokeCommand(
                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
            });
    }];

    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
}

- (void)instantActionWithTransitionWithParams:(MTRBridgedActionsClusterInstantActionWithTransitionParams *)params
                               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                BridgedActions::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::BridgedActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.InvokeCommand(
                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
            });
    }];

    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
}

- (void)startActionWithParams:(MTRBridgedActionsClusterStartActionParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                BridgedActions::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::BridgedActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.InvokeCommand(
                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
            });
    }];

    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
}

- (void)startActionWithDurationWithParams:(MTRBridgedActionsClusterStartActionWithDurationParams *)params
                           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                BridgedActions::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::BridgedActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.InvokeCommand(
                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
            });
    }];

    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
}

- (void)stopActionWithParams:(MTRBridgedActionsClusterStopActionParams *)params
              expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
           completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                BridgedActions::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::BridgedActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.InvokeCommand(
                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
            });
    }];

    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
}

- (void)pauseActionWithParams:(MTRBridgedActionsClusterPauseActionParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                BridgedActions::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::BridgedActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.InvokeCommand(
                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
            });
    }];

    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
}

- (void)pauseActionWithDurationWithParams:(MTRBridgedActionsClusterPauseActionWithDurationParams *)params
                           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                BridgedActions::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::BridgedActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.InvokeCommand(
                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
            });
    }];

    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
}

- (void)resumeActionWithParams:(MTRBridgedActionsClusterResumeActionParams *)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                BridgedActions::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::BridgedActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.InvokeCommand(
                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
            });
    }];

    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
}

- (void)enableActionWithParams:(MTRBridgedActionsClusterEnableActionParams *)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                BridgedActions::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::BridgedActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.InvokeCommand(
                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
            });
    }];

    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
}

- (void)enableActionWithDurationWithParams:(MTRBridgedActionsClusterEnableActionWithDurationParams *)params
                            expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                         completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                BridgedActions::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::BridgedActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.InvokeCommand(
                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
            });
    }];

    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
}

- (void)disableActionWithParams:(MTRBridgedActionsClusterDisableActionParams *)params
                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                BridgedActions::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::BridgedActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.InvokeCommand(
                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
            });
    }];

    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
}

- (void)disableActionWithDurationWithParams:(MTRBridgedActionsClusterDisableActionWithDurationParams *)params
                             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                          completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                BridgedActions::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::BridgedActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.InvokeCommand(
                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
            });
    }];

    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
}

- (NSDictionary<NSString *, id> *)readAttributeActionListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedActionsID)
                                        attributeId:@(MTRClusterBridgedActionsAttributeActionListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeEndpointListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedActionsID)
                                        attributeId:@(MTRClusterBridgedActionsAttributeEndpointListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSetupUrlWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedActionsID)
                                        attributeId:@(MTRClusterBridgedActionsAttributeSetupUrlID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedActionsID)
                                        attributeId:@(MTRClusterBridgedActionsAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedActionsID)
                                        attributeId:@(MTRClusterBridgedActionsAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedActionsID)
                                        attributeId:@(MTRClusterBridgedActionsAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedActionsID)
                                        attributeId:@(MTRClusterBridgedActionsAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedActionsID)
                                        attributeId:@(MTRClusterBridgedActionsAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterBasic

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)mfgSpecificPingWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                        completionHandler:(StatusCompletion)completionHandler
{
    [self mfgSpecificPingWithParams:nil
                     expectedValues:expectedValues
              expectedValueInterval:expectedValueIntervalMs
                  completionHandler:completionHandler];
}
- (void)mfgSpecificPingWithParams:(MTRBasicClusterMfgSpecificPingParams * _Nullable)params
                   expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeDataModelRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeDataModelRevisionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeVendorNameWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeVendorNameID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeVendorIDWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeVendorIDID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeProductNameWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeProductNameID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeProductIDWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeProductIDID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNodeLabelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeNodeLabelID)
                                             params:params];
}

- (void)writeAttributeNodeLabelWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNodeLabelWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNodeLabelWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                  params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBasicID)
                                  attributeId:@(MTRClusterBasicAttributeNodeLabelID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeLocationWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeLocationID)
                                             params:params];
}

- (void)writeAttributeLocationWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLocationWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeLocationWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBasicID)
                                  attributeId:@(MTRClusterBasicAttributeLocationID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeHardwareVersionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeHardwareVersionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeHardwareVersionStringWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeHardwareVersionStringID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSoftwareVersionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeSoftwareVersionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSoftwareVersionStringWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeSoftwareVersionStringID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeManufacturingDateWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeManufacturingDateID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePartNumberWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributePartNumberID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeProductURLWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeProductURLID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeProductLabelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeProductLabelID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSerialNumberWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeSerialNumberID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLocalConfigDisabledWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeLocalConfigDisabledID)
                                             params:params];
}

- (void)writeAttributeLocalConfigDisabledWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLocalConfigDisabledWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeLocalConfigDisabledWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBasicID)
                                  attributeId:@(MTRClusterBasicAttributeLocalConfigDisabledID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeReachableWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeReachableID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeUniqueIDWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeUniqueIDID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCapabilityMinimaWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeCapabilityMinimaID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBasicID)
                                        attributeId:@(MTRClusterBasicAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterOtaSoftwareUpdateProvider

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)queryImageWithParams:(MTROtaSoftwareUpdateProviderClusterQueryImageParams *)params
              expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
           completionHandler:(void (^)(MTROtaSoftwareUpdateProviderClusterQueryImageResponseParams * _Nullable data,
                                 NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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.
                                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();
                    }
                }
                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];
}

- (void)applyUpdateRequestWithParams:(MTROtaSoftwareUpdateProviderClusterApplyUpdateRequestParams *)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(void (^)(MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)notifyUpdateAppliedWithParams:(MTROtaSoftwareUpdateProviderClusterNotifyUpdateAppliedParams *)params
                       expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                    completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateProviderID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateProviderAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateProviderID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateProviderAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateProviderID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateProviderAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateProviderID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateProviderAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateProviderID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateProviderAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterOtaSoftwareUpdateRequestor

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)announceOtaProviderWithParams:(MTROtaSoftwareUpdateRequestorClusterAnnounceOtaProviderParams *)params
                       expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                    completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeDefaultOtaProvidersWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateRequestorID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateRequestorAttributeDefaultOtaProvidersID)
                                             params:params];
}

- (void)writeAttributeDefaultOtaProvidersWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeDefaultOtaProvidersWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeDefaultOtaProvidersWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOtaSoftwareUpdateRequestorID)
                                  attributeId:@(MTRClusterOtaSoftwareUpdateRequestorAttributeDefaultOtaProvidersID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeUpdatePossibleWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateRequestorID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateRequestorAttributeUpdatePossibleID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeUpdateStateWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateRequestorID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateRequestorAttributeUpdateStateID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeUpdateStateProgressWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateRequestorID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateRequestorAttributeUpdateStateProgressID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateRequestorID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateRequestorAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateRequestorID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateRequestorAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateRequestorID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateRequestorAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateRequestorID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateRequestorAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOtaSoftwareUpdateRequestorID)
                                        attributeId:@(MTRClusterOtaSoftwareUpdateRequestorAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterLocalizationConfiguration

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeActiveLocaleWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLocalizationConfigurationID)
                                        attributeId:@(MTRClusterLocalizationConfigurationAttributeActiveLocaleID)
                                             params:params];
}

- (void)writeAttributeActiveLocaleWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeActiveLocaleWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeActiveLocaleWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterLocalizationConfigurationID)
                                  attributeId:@(MTRClusterLocalizationConfigurationAttributeActiveLocaleID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeSupportedLocalesWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLocalizationConfigurationID)
                                        attributeId:@(MTRClusterLocalizationConfigurationAttributeSupportedLocalesID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLocalizationConfigurationID)
                                        attributeId:@(MTRClusterLocalizationConfigurationAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLocalizationConfigurationID)
                                        attributeId:@(MTRClusterLocalizationConfigurationAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLocalizationConfigurationID)
                                        attributeId:@(MTRClusterLocalizationConfigurationAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLocalizationConfigurationID)
                                        attributeId:@(MTRClusterLocalizationConfigurationAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLocalizationConfigurationID)
                                        attributeId:@(MTRClusterLocalizationConfigurationAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterTimeFormatLocalization

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeHourFormatWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTimeFormatLocalizationID)
                                        attributeId:@(MTRClusterTimeFormatLocalizationAttributeHourFormatID)
                                             params:params];
}

- (void)writeAttributeHourFormatWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeHourFormatWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeHourFormatWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                   params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTimeFormatLocalizationID)
                                  attributeId:@(MTRClusterTimeFormatLocalizationAttributeHourFormatID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeActiveCalendarTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTimeFormatLocalizationID)
                                        attributeId:@(MTRClusterTimeFormatLocalizationAttributeActiveCalendarTypeID)
                                             params:params];
}

- (void)writeAttributeActiveCalendarTypeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeActiveCalendarTypeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeActiveCalendarTypeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                           params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTimeFormatLocalizationID)
                                  attributeId:@(MTRClusterTimeFormatLocalizationAttributeActiveCalendarTypeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeSupportedCalendarTypesWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTimeFormatLocalizationID)
                                        attributeId:@(MTRClusterTimeFormatLocalizationAttributeSupportedCalendarTypesID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTimeFormatLocalizationID)
                                        attributeId:@(MTRClusterTimeFormatLocalizationAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTimeFormatLocalizationID)
                                        attributeId:@(MTRClusterTimeFormatLocalizationAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTimeFormatLocalizationID)
                                        attributeId:@(MTRClusterTimeFormatLocalizationAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTimeFormatLocalizationID)
                                        attributeId:@(MTRClusterTimeFormatLocalizationAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTimeFormatLocalizationID)
                                        attributeId:@(MTRClusterTimeFormatLocalizationAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterUnitLocalization

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeTemperatureUnitWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterUnitLocalizationID)
                                        attributeId:@(MTRClusterUnitLocalizationAttributeTemperatureUnitID)
                                             params:params];
}

- (void)writeAttributeTemperatureUnitWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeTemperatureUnitWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeTemperatureUnitWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                        params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterUnitLocalizationID)
                                  attributeId:@(MTRClusterUnitLocalizationAttributeTemperatureUnitID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterUnitLocalizationID)
                                        attributeId:@(MTRClusterUnitLocalizationAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterUnitLocalizationID)
                                        attributeId:@(MTRClusterUnitLocalizationAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterUnitLocalizationID)
                                        attributeId:@(MTRClusterUnitLocalizationAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterUnitLocalizationID)
                                        attributeId:@(MTRClusterUnitLocalizationAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterUnitLocalizationID)
                                        attributeId:@(MTRClusterUnitLocalizationAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterPowerSourceConfiguration

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeSourcesWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceConfigurationID)
                                        attributeId:@(MTRClusterPowerSourceConfigurationAttributeSourcesID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceConfigurationID)
                                        attributeId:@(MTRClusterPowerSourceConfigurationAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceConfigurationID)
                                        attributeId:@(MTRClusterPowerSourceConfigurationAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceConfigurationID)
                                        attributeId:@(MTRClusterPowerSourceConfigurationAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceConfigurationID)
                                        attributeId:@(MTRClusterPowerSourceConfigurationAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceConfigurationID)
                                        attributeId:@(MTRClusterPowerSourceConfigurationAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterPowerSource

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeStatusWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeStatusID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOrderWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeOrderID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDescriptionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeDescriptionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeWiredAssessedInputVoltageWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeWiredAssessedInputVoltageID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeWiredAssessedInputFrequencyWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeWiredAssessedInputFrequencyID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeWiredCurrentTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeWiredCurrentTypeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeWiredAssessedCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeWiredAssessedCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeWiredNominalVoltageWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeWiredNominalVoltageID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeWiredMaximumCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeWiredMaximumCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeWiredPresentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeWiredPresentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActiveWiredFaultsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeActiveWiredFaultsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatVoltageWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatVoltageID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatPercentRemainingWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatPercentRemainingID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatTimeRemainingWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatTimeRemainingID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatChargeLevelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatChargeLevelID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatReplacementNeededWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatReplacementNeededID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatReplaceabilityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatReplaceabilityID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatPresentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatPresentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActiveBatFaultsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeActiveBatFaultsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatReplacementDescriptionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatReplacementDescriptionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatCommonDesignationWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatCommonDesignationID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatANSIDesignationWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatANSIDesignationID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatIECDesignationWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatIECDesignationID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatApprovedChemistryWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatApprovedChemistryID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatCapacityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatCapacityID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatQuantityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatQuantityID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatChargeStateWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatChargeStateID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatTimeToFullChargeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatTimeToFullChargeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatFunctionalWhileChargingWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatFunctionalWhileChargingID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBatChargingCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeBatChargingCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActiveBatChargeFaultsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeActiveBatChargeFaultsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPowerSourceID)
                                        attributeId:@(MTRClusterPowerSourceAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterGeneralCommissioning

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)armFailSafeWithParams:(MTRGeneralCommissioningClusterArmFailSafeParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(void (^)(MTRGeneralCommissioningClusterArmFailSafeResponseParams * _Nullable data,
                                  NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)setRegulatoryConfigWithParams:(MTRGeneralCommissioningClusterSetRegulatoryConfigParams *)params
                       expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                    completionHandler:(void (^)(MTRGeneralCommissioningClusterSetRegulatoryConfigResponseParams * _Nullable data,
                                          NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)commissioningCompleteWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                              completionHandler:
                                  (void (^)(MTRGeneralCommissioningClusterCommissioningCompleteResponseParams * _Nullable data,
                                      NSError * _Nullable error))completionHandler
{
    [self commissioningCompleteWithParams:nil
                           expectedValues:expectedValues
                    expectedValueInterval:expectedValueIntervalMs
                        completionHandler:completionHandler];
}
- (void)commissioningCompleteWithParams:(MTRGeneralCommissioningClusterCommissioningCompleteParams * _Nullable)params
                         expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                      completionHandler:
                          (void (^)(MTRGeneralCommissioningClusterCommissioningCompleteResponseParams * _Nullable data,
                              NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }

                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];
}

- (NSDictionary<NSString *, id> *)readAttributeBreadcrumbWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralCommissioningID)
                                        attributeId:@(MTRClusterGeneralCommissioningAttributeBreadcrumbID)
                                             params:params];
}

- (void)writeAttributeBreadcrumbWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBreadcrumbWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeBreadcrumbWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                   params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterGeneralCommissioningID)
                                  attributeId:@(MTRClusterGeneralCommissioningAttributeBreadcrumbID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeBasicCommissioningInfoWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralCommissioningID)
                                        attributeId:@(MTRClusterGeneralCommissioningAttributeBasicCommissioningInfoID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRegulatoryConfigWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralCommissioningID)
                                        attributeId:@(MTRClusterGeneralCommissioningAttributeRegulatoryConfigID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLocationCapabilityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralCommissioningID)
                                        attributeId:@(MTRClusterGeneralCommissioningAttributeLocationCapabilityID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSupportsConcurrentConnectionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralCommissioningID)
                                        attributeId:@(MTRClusterGeneralCommissioningAttributeSupportsConcurrentConnectionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralCommissioningID)
                                        attributeId:@(MTRClusterGeneralCommissioningAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralCommissioningID)
                                        attributeId:@(MTRClusterGeneralCommissioningAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralCommissioningID)
                                        attributeId:@(MTRClusterGeneralCommissioningAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralCommissioningID)
                                        attributeId:@(MTRClusterGeneralCommissioningAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralCommissioningID)
                                        attributeId:@(MTRClusterGeneralCommissioningAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterNetworkCommissioning

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)scanNetworksWithParams:(MTRNetworkCommissioningClusterScanNetworksParams * _Nullable)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(void (^)(MTRNetworkCommissioningClusterScanNetworksResponseParams * _Nullable data,
                                   NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
                        }
                    }
                    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];
}

- (void)addOrUpdateWiFiNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateWiFiNetworkParams *)params
                          expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                       completionHandler:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data,
                                             NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)addOrUpdateThreadNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateThreadNetworkParams *)params
                            expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                         completionHandler:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data,
                                               NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)removeNetworkWithParams:(MTRNetworkCommissioningClusterRemoveNetworkParams *)params
                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data,
                                    NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)connectNetworkWithParams:(MTRNetworkCommissioningClusterConnectNetworkParams *)params
                  expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
               completionHandler:(void (^)(MTRNetworkCommissioningClusterConnectNetworkResponseParams * _Nullable data,
                                     NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)reorderNetworkWithParams:(MTRNetworkCommissioningClusterReorderNetworkParams *)params
                  expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
               completionHandler:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data,
                                     NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxNetworksWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterNetworkCommissioningID)
                                        attributeId:@(MTRClusterNetworkCommissioningAttributeMaxNetworksID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNetworksWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterNetworkCommissioningID)
                                        attributeId:@(MTRClusterNetworkCommissioningAttributeNetworksID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeScanMaxTimeSecondsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterNetworkCommissioningID)
                                        attributeId:@(MTRClusterNetworkCommissioningAttributeScanMaxTimeSecondsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeConnectMaxTimeSecondsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterNetworkCommissioningID)
                                        attributeId:@(MTRClusterNetworkCommissioningAttributeConnectMaxTimeSecondsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeInterfaceEnabledWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterNetworkCommissioningID)
                                        attributeId:@(MTRClusterNetworkCommissioningAttributeInterfaceEnabledID)
                                             params:params];
}

- (void)writeAttributeInterfaceEnabledWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInterfaceEnabledWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInterfaceEnabledWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                         params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterNetworkCommissioningID)
                                  attributeId:@(MTRClusterNetworkCommissioningAttributeInterfaceEnabledID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeLastNetworkingStatusWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterNetworkCommissioningID)
                                        attributeId:@(MTRClusterNetworkCommissioningAttributeLastNetworkingStatusID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLastNetworkIDWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterNetworkCommissioningID)
                                        attributeId:@(MTRClusterNetworkCommissioningAttributeLastNetworkIDID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLastConnectErrorValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterNetworkCommissioningID)
                                        attributeId:@(MTRClusterNetworkCommissioningAttributeLastConnectErrorValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterNetworkCommissioningID)
                                        attributeId:@(MTRClusterNetworkCommissioningAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterNetworkCommissioningID)
                                        attributeId:@(MTRClusterNetworkCommissioningAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterNetworkCommissioningID)
                                        attributeId:@(MTRClusterNetworkCommissioningAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterNetworkCommissioningID)
                                        attributeId:@(MTRClusterNetworkCommissioningAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterNetworkCommissioningID)
                                        attributeId:@(MTRClusterNetworkCommissioningAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterDiagnosticLogs

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)retrieveLogsRequestWithParams:(MTRDiagnosticLogsClusterRetrieveLogsRequestParams *)params
                       expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                    completionHandler:(void (^)(MTRDiagnosticLogsClusterRetrieveLogsResponseParams * _Nullable data,
                                          NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDiagnosticLogsID)
                                        attributeId:@(MTRClusterDiagnosticLogsAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDiagnosticLogsID)
                                        attributeId:@(MTRClusterDiagnosticLogsAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDiagnosticLogsID)
                                        attributeId:@(MTRClusterDiagnosticLogsAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDiagnosticLogsID)
                                        attributeId:@(MTRClusterDiagnosticLogsAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDiagnosticLogsID)
                                        attributeId:@(MTRClusterDiagnosticLogsAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterGeneralDiagnostics

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)testEventTriggerWithParams:(MTRGeneralDiagnosticsClusterTestEventTriggerParams *)params
                    expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                 completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeNetworkInterfacesWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeNetworkInterfacesID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRebootCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeRebootCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeUpTimeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeUpTimeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTotalOperationalHoursWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeTotalOperationalHoursID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBootReasonsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeBootReasonsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActiveHardwareFaultsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeActiveHardwareFaultsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActiveRadioFaultsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeActiveRadioFaultsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActiveNetworkFaultsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeActiveNetworkFaultsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTestEventTriggersEnabledWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeTestEventTriggersEnabledID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGeneralDiagnosticsID)
                                        attributeId:@(MTRClusterGeneralDiagnosticsAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterSoftwareDiagnostics

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)resetWatermarksWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                        completionHandler:(StatusCompletion)completionHandler
{
    [self resetWatermarksWithParams:nil
                     expectedValues:expectedValues
              expectedValueInterval:expectedValueIntervalMs
                  completionHandler:completionHandler];
}
- (void)resetWatermarksWithParams:(MTRSoftwareDiagnosticsClusterResetWatermarksParams * _Nullable)params
                   expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeThreadMetricsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSoftwareDiagnosticsID)
                                        attributeId:@(MTRClusterSoftwareDiagnosticsAttributeThreadMetricsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentHeapFreeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSoftwareDiagnosticsID)
                                        attributeId:@(MTRClusterSoftwareDiagnosticsAttributeCurrentHeapFreeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentHeapUsedWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSoftwareDiagnosticsID)
                                        attributeId:@(MTRClusterSoftwareDiagnosticsAttributeCurrentHeapUsedID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentHeapHighWatermarkWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSoftwareDiagnosticsID)
                                        attributeId:@(MTRClusterSoftwareDiagnosticsAttributeCurrentHeapHighWatermarkID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSoftwareDiagnosticsID)
                                        attributeId:@(MTRClusterSoftwareDiagnosticsAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSoftwareDiagnosticsID)
                                        attributeId:@(MTRClusterSoftwareDiagnosticsAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSoftwareDiagnosticsID)
                                        attributeId:@(MTRClusterSoftwareDiagnosticsAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSoftwareDiagnosticsID)
                                        attributeId:@(MTRClusterSoftwareDiagnosticsAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSoftwareDiagnosticsID)
                                        attributeId:@(MTRClusterSoftwareDiagnosticsAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterThreadNetworkDiagnostics

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)resetCountsWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                    completionHandler:(StatusCompletion)completionHandler
{
    [self resetCountsWithParams:nil
                 expectedValues:expectedValues
          expectedValueInterval:expectedValueIntervalMs
              completionHandler:completionHandler];
}
- (void)resetCountsWithParams:(MTRThreadNetworkDiagnosticsClusterResetCountsParams * _Nullable)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeChannelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeChannelID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRoutingRoleWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRoutingRoleID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNetworkNameWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeNetworkNameID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePanIdWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributePanIdID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeExtendedPanIdWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeExtendedPanIdID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMeshLocalPrefixWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeMeshLocalPrefixID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOverrunCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeOverrunCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNeighborTableListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeNeighborTableListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRouteTableListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRouteTableListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePartitionIdWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributePartitionIdID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeWeightingWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeWeightingID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDataVersionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeDataVersionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeStableDataVersionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeStableDataVersionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLeaderRouterIdWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeLeaderRouterIdID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDetachedRoleCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeDetachedRoleCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeChildRoleCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeChildRoleCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRouterRoleCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRouterRoleCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLeaderRoleCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeLeaderRoleCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttachAttemptCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeAttachAttemptCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePartitionIdChangeCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributePartitionIdChangeCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBetterPartitionAttachAttemptCountWithParams:(MTRReadParams * _Nullable)params
{
    return
        [self.device readAttributeWithEndpointId:@(_endpoint)
                                       clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                     attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeBetterPartitionAttachAttemptCountID)
                                          params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeParentChangeCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeParentChangeCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxTotalCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxTotalCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxUnicastCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxUnicastCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxBroadcastCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxBroadcastCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxAckRequestedCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxAckRequestedCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxAckedCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxAckedCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxNoAckRequestedCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxNoAckRequestedCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxDataCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxDataCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxDataPollCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxDataPollCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxBeaconCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxBeaconCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxBeaconRequestCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxBeaconRequestCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxOtherCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxOtherCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxRetryCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxRetryCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxDirectMaxRetryExpiryCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxDirectMaxRetryExpiryCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxIndirectMaxRetryExpiryCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxIndirectMaxRetryExpiryCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxErrCcaCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxErrCcaCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxErrAbortCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxErrAbortCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxErrBusyChannelCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeTxErrBusyChannelCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxTotalCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxTotalCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxUnicastCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxUnicastCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxBroadcastCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxBroadcastCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxDataCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxDataCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxDataPollCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxDataPollCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxBeaconCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxBeaconCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxBeaconRequestCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxBeaconRequestCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxOtherCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxOtherCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxAddressFilteredCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxAddressFilteredCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxDestAddrFilteredCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxDestAddrFilteredCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxDuplicatedCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxDuplicatedCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxErrNoFrameCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxErrNoFrameCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxErrUnknownNeighborCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxErrUnknownNeighborCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxErrInvalidSrcAddrCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxErrInvalidSrcAddrCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxErrSecCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxErrSecCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxErrFcsCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxErrFcsCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRxErrOtherCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeRxErrOtherCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActiveTimestampWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeActiveTimestampID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePendingTimestampWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributePendingTimestampID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDelayWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeDelayID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSecurityPolicyWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeSecurityPolicyID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeChannelPage0MaskWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeChannelPage0MaskID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOperationalDatasetComponentsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeOperationalDatasetComponentsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActiveNetworkFaultsListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeActiveNetworkFaultsListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThreadNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterThreadNetworkDiagnosticsAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterWiFiNetworkDiagnostics

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)resetCountsWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                    completionHandler:(StatusCompletion)completionHandler
{
    [self resetCountsWithParams:nil
                 expectedValues:expectedValues
          expectedValueInterval:expectedValueIntervalMs
              completionHandler:completionHandler];
}
- (void)resetCountsWithParams:(MTRWiFiNetworkDiagnosticsClusterResetCountsParams * _Nullable)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeBssidWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeBssidID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSecurityTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeSecurityTypeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeWiFiVersionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeWiFiVersionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeChannelNumberWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeChannelNumberID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRssiWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeRssiID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBeaconLostCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeBeaconLostCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBeaconRxCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeBeaconRxCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePacketMulticastRxCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributePacketMulticastRxCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePacketMulticastTxCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributePacketMulticastTxCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePacketUnicastRxCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributePacketUnicastRxCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePacketUnicastTxCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributePacketUnicastTxCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentMaxRateWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeCurrentMaxRateID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOverrunCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeOverrunCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWiFiNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterWiFiNetworkDiagnosticsAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterEthernetNetworkDiagnostics

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)resetCountsWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                    completionHandler:(StatusCompletion)completionHandler
{
    [self resetCountsWithParams:nil
                 expectedValues:expectedValues
          expectedValueInterval:expectedValueIntervalMs
              completionHandler:completionHandler];
}
- (void)resetCountsWithParams:(MTREthernetNetworkDiagnosticsClusterResetCountsParams * _Nullable)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributePHYRateWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributePHYRateID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFullDuplexWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributeFullDuplexID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePacketRxCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributePacketRxCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePacketTxCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributePacketTxCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTxErrCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributeTxErrCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCollisionCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributeCollisionCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOverrunCountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributeOverrunCountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCarrierDetectWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributeCarrierDetectID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTimeSinceResetWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributeTimeSinceResetID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterEthernetNetworkDiagnosticsID)
                                        attributeId:@(MTRClusterEthernetNetworkDiagnosticsAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterBridgedDeviceBasic

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeVendorNameWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeVendorNameID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeVendorIDWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeVendorIDID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeProductNameWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeProductNameID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNodeLabelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeNodeLabelID)
                                             params:params];
}

- (void)writeAttributeNodeLabelWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNodeLabelWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNodeLabelWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                  params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBridgedDeviceBasicID)
                                  attributeId:@(MTRClusterBridgedDeviceBasicAttributeNodeLabelID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeHardwareVersionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeHardwareVersionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeHardwareVersionStringWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeHardwareVersionStringID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSoftwareVersionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeSoftwareVersionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSoftwareVersionStringWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeSoftwareVersionStringID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeManufacturingDateWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeManufacturingDateID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePartNumberWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributePartNumberID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeProductURLWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeProductURLID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeProductLabelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeProductLabelID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSerialNumberWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeSerialNumberID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeReachableWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeReachableID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeUniqueIDWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeUniqueIDID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBridgedDeviceBasicID)
                                        attributeId:@(MTRClusterBridgedDeviceBasicAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterSwitch

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeNumberOfPositionsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSwitchID)
                                        attributeId:@(MTRClusterSwitchAttributeNumberOfPositionsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentPositionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSwitchID)
                                        attributeId:@(MTRClusterSwitchAttributeCurrentPositionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMultiPressMaxWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSwitchID)
                                        attributeId:@(MTRClusterSwitchAttributeMultiPressMaxID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSwitchID)
                                        attributeId:@(MTRClusterSwitchAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSwitchID)
                                        attributeId:@(MTRClusterSwitchAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSwitchID)
                                        attributeId:@(MTRClusterSwitchAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSwitchID)
                                        attributeId:@(MTRClusterSwitchAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterSwitchID)
                                        attributeId:@(MTRClusterSwitchAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterAdministratorCommissioning

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)openCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterOpenCommissioningWindowParams *)params
                           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)openBasicCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterOpenBasicCommissioningWindowParams *)params
                                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                             completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)revokeCommissioningWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                            completionHandler:(StatusCompletion)completionHandler
{
    [self revokeCommissioningWithParams:nil
                         expectedValues:expectedValues
                  expectedValueInterval:expectedValueIntervalMs
                      completionHandler:completionHandler];
}
- (void)revokeCommissioningWithParams:(MTRAdministratorCommissioningClusterRevokeCommissioningParams * _Nullable)params
                       expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                    completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeWindowStatusWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAdministratorCommissioningID)
                                        attributeId:@(MTRClusterAdministratorCommissioningAttributeWindowStatusID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAdminFabricIndexWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAdministratorCommissioningID)
                                        attributeId:@(MTRClusterAdministratorCommissioningAttributeAdminFabricIndexID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAdminVendorIdWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAdministratorCommissioningID)
                                        attributeId:@(MTRClusterAdministratorCommissioningAttributeAdminVendorIdID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAdministratorCommissioningID)
                                        attributeId:@(MTRClusterAdministratorCommissioningAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAdministratorCommissioningID)
                                        attributeId:@(MTRClusterAdministratorCommissioningAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAdministratorCommissioningID)
                                        attributeId:@(MTRClusterAdministratorCommissioningAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAdministratorCommissioningID)
                                        attributeId:@(MTRClusterAdministratorCommissioningAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAdministratorCommissioningID)
                                        attributeId:@(MTRClusterAdministratorCommissioningAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterOperationalCredentials

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)attestationRequestWithParams:(MTROperationalCredentialsClusterAttestationRequestParams *)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(void (^)(MTROperationalCredentialsClusterAttestationResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)certificateChainRequestWithParams:(MTROperationalCredentialsClusterCertificateChainRequestParams *)params
                           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                        completionHandler:(void (^)(MTROperationalCredentialsClusterCertificateChainResponseParams * _Nullable data,
                                              NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)CSRRequestWithParams:(MTROperationalCredentialsClusterCSRRequestParams *)params
              expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
           completionHandler:(void (^)(MTROperationalCredentialsClusterCSRResponseParams * _Nullable data,
                                 NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)addNOCWithParams:(MTROperationalCredentialsClusterAddNOCParams *)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data,
                              NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)updateNOCWithParams:(MTROperationalCredentialsClusterUpdateNOCParams *)params
             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
          completionHandler:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data,
                                NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)updateFabricLabelWithParams:(MTROperationalCredentialsClusterUpdateFabricLabelParams *)params
                     expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                  completionHandler:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data,
                                        NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)removeFabricWithParams:(MTROperationalCredentialsClusterRemoveFabricParams *)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data,
                                   NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)addTrustedRootCertificateWithParams:(MTROperationalCredentialsClusterAddTrustedRootCertificateParams *)params
                             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                          completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeNOCsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOperationalCredentialsID)
                                        attributeId:@(MTRClusterOperationalCredentialsAttributeNOCsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFabricsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOperationalCredentialsID)
                                        attributeId:@(MTRClusterOperationalCredentialsAttributeFabricsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSupportedFabricsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOperationalCredentialsID)
                                        attributeId:@(MTRClusterOperationalCredentialsAttributeSupportedFabricsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCommissionedFabricsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOperationalCredentialsID)
                                        attributeId:@(MTRClusterOperationalCredentialsAttributeCommissionedFabricsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTrustedRootCertificatesWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOperationalCredentialsID)
                                        attributeId:@(MTRClusterOperationalCredentialsAttributeTrustedRootCertificatesID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentFabricIndexWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOperationalCredentialsID)
                                        attributeId:@(MTRClusterOperationalCredentialsAttributeCurrentFabricIndexID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOperationalCredentialsID)
                                        attributeId:@(MTRClusterOperationalCredentialsAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOperationalCredentialsID)
                                        attributeId:@(MTRClusterOperationalCredentialsAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOperationalCredentialsID)
                                        attributeId:@(MTRClusterOperationalCredentialsAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOperationalCredentialsID)
                                        attributeId:@(MTRClusterOperationalCredentialsAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOperationalCredentialsID)
                                        attributeId:@(MTRClusterOperationalCredentialsAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterGroupKeyManagement

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)keySetWriteWithParams:(MTRGroupKeyManagementClusterKeySetWriteParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)keySetReadWithParams:(MTRGroupKeyManagementClusterKeySetReadParams *)params
              expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
           completionHandler:(void (^)(MTRGroupKeyManagementClusterKeySetReadResponseParams * _Nullable data,
                                 NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)keySetRemoveWithParams:(MTRGroupKeyManagementClusterKeySetRemoveParams *)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)keySetReadAllIndicesWithParams:(MTRGroupKeyManagementClusterKeySetReadAllIndicesParams *)params
                        expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                     completionHandler:(void (^)(MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseParams * _Nullable data,
                                           NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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.
                                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();
                    }
                }

                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];
}

- (NSDictionary<NSString *, id> *)readAttributeGroupKeyMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupKeyManagementID)
                                        attributeId:@(MTRClusterGroupKeyManagementAttributeGroupKeyMapID)
                                             params:params];
}

- (void)writeAttributeGroupKeyMapWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeGroupKeyMapWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeGroupKeyMapWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterGroupKeyManagementID)
                                  attributeId:@(MTRClusterGroupKeyManagementAttributeGroupKeyMapID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGroupTableWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupKeyManagementID)
                                        attributeId:@(MTRClusterGroupKeyManagementAttributeGroupTableID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxGroupsPerFabricWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupKeyManagementID)
                                        attributeId:@(MTRClusterGroupKeyManagementAttributeMaxGroupsPerFabricID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxGroupKeysPerFabricWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupKeyManagementID)
                                        attributeId:@(MTRClusterGroupKeyManagementAttributeMaxGroupKeysPerFabricID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupKeyManagementID)
                                        attributeId:@(MTRClusterGroupKeyManagementAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupKeyManagementID)
                                        attributeId:@(MTRClusterGroupKeyManagementAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupKeyManagementID)
                                        attributeId:@(MTRClusterGroupKeyManagementAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupKeyManagementID)
                                        attributeId:@(MTRClusterGroupKeyManagementAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterGroupKeyManagementID)
                                        attributeId:@(MTRClusterGroupKeyManagementAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterFixedLabel

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeLabelListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFixedLabelID)
                                        attributeId:@(MTRClusterFixedLabelAttributeLabelListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFixedLabelID)
                                        attributeId:@(MTRClusterFixedLabelAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFixedLabelID)
                                        attributeId:@(MTRClusterFixedLabelAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFixedLabelID)
                                        attributeId:@(MTRClusterFixedLabelAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFixedLabelID)
                                        attributeId:@(MTRClusterFixedLabelAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFixedLabelID)
                                        attributeId:@(MTRClusterFixedLabelAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterUserLabel

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeLabelListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterUserLabelID)
                                        attributeId:@(MTRClusterUserLabelAttributeLabelListID)
                                             params:params];
}

- (void)writeAttributeLabelListWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLabelListWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeLabelListWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                  params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterUserLabelID)
                                  attributeId:@(MTRClusterUserLabelAttributeLabelListID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterUserLabelID)
                                        attributeId:@(MTRClusterUserLabelAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterUserLabelID)
                                        attributeId:@(MTRClusterUserLabelAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterUserLabelID)
                                        attributeId:@(MTRClusterUserLabelAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterUserLabelID)
                                        attributeId:@(MTRClusterUserLabelAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterUserLabelID)
                                        attributeId:@(MTRClusterUserLabelAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterBooleanState

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeStateValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBooleanStateID)
                                        attributeId:@(MTRClusterBooleanStateAttributeStateValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBooleanStateID)
                                        attributeId:@(MTRClusterBooleanStateAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBooleanStateID)
                                        attributeId:@(MTRClusterBooleanStateAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBooleanStateID)
                                        attributeId:@(MTRClusterBooleanStateAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBooleanStateID)
                                        attributeId:@(MTRClusterBooleanStateAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBooleanStateID)
                                        attributeId:@(MTRClusterBooleanStateAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterModeSelect

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)changeToModeWithParams:(MTRModeSelectClusterChangeToModeParams *)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeDescriptionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterModeSelectID)
                                        attributeId:@(MTRClusterModeSelectAttributeDescriptionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeStandardNamespaceWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterModeSelectID)
                                        attributeId:@(MTRClusterModeSelectAttributeStandardNamespaceID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSupportedModesWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterModeSelectID)
                                        attributeId:@(MTRClusterModeSelectAttributeSupportedModesID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterModeSelectID)
                                        attributeId:@(MTRClusterModeSelectAttributeCurrentModeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeStartUpModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterModeSelectID)
                                        attributeId:@(MTRClusterModeSelectAttributeStartUpModeID)
                                             params:params];
}

- (void)writeAttributeStartUpModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeStartUpModeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeStartUpModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterModeSelectID)
                                  attributeId:@(MTRClusterModeSelectAttributeStartUpModeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOnModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterModeSelectID)
                                        attributeId:@(MTRClusterModeSelectAttributeOnModeID)
                                             params:params];
}

- (void)writeAttributeOnModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOnModeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOnModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterModeSelectID)
                                  attributeId:@(MTRClusterModeSelectAttributeOnModeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterModeSelectID)
                                        attributeId:@(MTRClusterModeSelectAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterModeSelectID)
                                        attributeId:@(MTRClusterModeSelectAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterModeSelectID)
                                        attributeId:@(MTRClusterModeSelectAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterModeSelectID)
                                        attributeId:@(MTRClusterModeSelectAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterModeSelectID)
                                        attributeId:@(MTRClusterModeSelectAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterDoorLock

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)lockDoorWithParams:(MTRDoorLockClusterLockDoorParams * _Nullable)params
            expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
         completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
                    }
                }

                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];
}

- (void)unlockDoorWithParams:(MTRDoorLockClusterUnlockDoorParams * _Nullable)params
              expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
           completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
                    }
                }

                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];
}

- (void)unlockWithTimeoutWithParams:(MTRDoorLockClusterUnlockWithTimeoutParams *)params
                     expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                  completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)setWeekDayScheduleWithParams:(MTRDoorLockClusterSetWeekDayScheduleParams *)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)getWeekDayScheduleWithParams:(MTRDoorLockClusterGetWeekDayScheduleParams *)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(void (^)(MTRDoorLockClusterGetWeekDayScheduleResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)clearWeekDayScheduleWithParams:(MTRDoorLockClusterClearWeekDayScheduleParams *)params
                        expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                     completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)setYearDayScheduleWithParams:(MTRDoorLockClusterSetYearDayScheduleParams *)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)getYearDayScheduleWithParams:(MTRDoorLockClusterGetYearDayScheduleParams *)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(void (^)(MTRDoorLockClusterGetYearDayScheduleResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)clearYearDayScheduleWithParams:(MTRDoorLockClusterClearYearDayScheduleParams *)params
                        expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                     completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)setHolidayScheduleWithParams:(MTRDoorLockClusterSetHolidayScheduleParams *)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)getHolidayScheduleWithParams:(MTRDoorLockClusterGetHolidayScheduleParams *)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(void (^)(MTRDoorLockClusterGetHolidayScheduleResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)clearHolidayScheduleWithParams:(MTRDoorLockClusterClearHolidayScheduleParams *)params
                        expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                     completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)setUserWithParams:(MTRDoorLockClusterSetUserParams *)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)getUserWithParams:(MTRDoorLockClusterGetUserParams *)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:
            (void (^)(MTRDoorLockClusterGetUserResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)clearUserWithParams:(MTRDoorLockClusterClearUserParams *)params
             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
          completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)setCredentialWithParams:(MTRDoorLockClusterSetCredentialParams *)params
                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(void (^)(MTRDoorLockClusterSetCredentialResponseParams * _Nullable data,
                                    NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)getCredentialStatusWithParams:(MTRDoorLockClusterGetCredentialStatusParams *)params
                       expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                    completionHandler:(void (^)(MTRDoorLockClusterGetCredentialStatusResponseParams * _Nullable data,
                                          NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)clearCredentialWithParams:(MTRDoorLockClusterClearCredentialParams *)params
                   expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeLockStateWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeLockStateID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLockTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeLockTypeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActuatorEnabledWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeActuatorEnabledID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDoorStateWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeDoorStateID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDoorOpenEventsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeDoorOpenEventsID)
                                             params:params];
}

- (void)writeAttributeDoorOpenEventsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeDoorOpenEventsWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeDoorOpenEventsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeDoorOpenEventsID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeDoorClosedEventsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeDoorClosedEventsID)
                                             params:params];
}

- (void)writeAttributeDoorClosedEventsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeDoorClosedEventsWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeDoorClosedEventsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                         params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeDoorClosedEventsID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOpenPeriodWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeOpenPeriodID)
                                             params:params];
}

- (void)writeAttributeOpenPeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOpenPeriodWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOpenPeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                   params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeOpenPeriodID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNumberOfTotalUsersSupportedWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeNumberOfTotalUsersSupportedID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNumberOfPINUsersSupportedWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeNumberOfPINUsersSupportedID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNumberOfRFIDUsersSupportedWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeNumberOfRFIDUsersSupportedID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeNumberOfWeekDaySchedulesSupportedPerUserID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeNumberOfYearDaySchedulesSupportedPerUserID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNumberOfHolidaySchedulesSupportedWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeNumberOfHolidaySchedulesSupportedID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxPINCodeLengthWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeMaxPINCodeLengthID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinPINCodeLengthWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeMinPINCodeLengthID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxRFIDCodeLengthWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeMaxRFIDCodeLengthID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinRFIDCodeLengthWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeMinRFIDCodeLengthID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCredentialRulesSupportWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeCredentialRulesSupportID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNumberOfCredentialsSupportedPerUserWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeNumberOfCredentialsSupportedPerUserID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLanguageWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeLanguageID)
                                             params:params];
}

- (void)writeAttributeLanguageWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLanguageWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeLanguageWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeLanguageID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeLEDSettingsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeLEDSettingsID)
                                             params:params];
}

- (void)writeAttributeLEDSettingsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLEDSettingsWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeLEDSettingsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeLEDSettingsID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeAutoRelockTimeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeAutoRelockTimeID)
                                             params:params];
}

- (void)writeAttributeAutoRelockTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeAutoRelockTimeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeAutoRelockTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeAutoRelockTimeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeSoundVolumeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeSoundVolumeID)
                                             params:params];
}

- (void)writeAttributeSoundVolumeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeSoundVolumeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeSoundVolumeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeSoundVolumeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOperatingModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeOperatingModeID)
                                             params:params];
}

- (void)writeAttributeOperatingModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOperatingModeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOperatingModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeOperatingModeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeSupportedOperatingModesWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeSupportedOperatingModesID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDefaultConfigurationRegisterWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeDefaultConfigurationRegisterID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeEnableLocalProgrammingWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeEnableLocalProgrammingID)
                                             params:params];
}

- (void)writeAttributeEnableLocalProgrammingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeEnableLocalProgrammingWithValue:dataValueDictionary
                                  expectedValueInterval:expectedValueIntervalMs
                                                 params:nil];
}
- (void)writeAttributeEnableLocalProgrammingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeEnableLocalProgrammingID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeEnableOneTouchLockingWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeEnableOneTouchLockingID)
                                             params:params];
}

- (void)writeAttributeEnableOneTouchLockingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeEnableOneTouchLockingWithValue:dataValueDictionary
                                 expectedValueInterval:expectedValueIntervalMs
                                                params:nil];
}
- (void)writeAttributeEnableOneTouchLockingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                              params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeEnableOneTouchLockingID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeEnableInsideStatusLEDWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeEnableInsideStatusLEDID)
                                             params:params];
}

- (void)writeAttributeEnableInsideStatusLEDWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeEnableInsideStatusLEDWithValue:dataValueDictionary
                                 expectedValueInterval:expectedValueIntervalMs
                                                params:nil];
}
- (void)writeAttributeEnableInsideStatusLEDWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                              params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeEnableInsideStatusLEDID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeEnablePrivacyModeButtonWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeEnablePrivacyModeButtonID)
                                             params:params];
}

- (void)writeAttributeEnablePrivacyModeButtonWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeEnablePrivacyModeButtonWithValue:dataValueDictionary
                                   expectedValueInterval:expectedValueIntervalMs
                                                  params:nil];
}
- (void)writeAttributeEnablePrivacyModeButtonWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeEnablePrivacyModeButtonID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeLocalProgrammingFeaturesWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeLocalProgrammingFeaturesID)
                                             params:params];
}

- (void)writeAttributeLocalProgrammingFeaturesWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLocalProgrammingFeaturesWithValue:dataValueDictionary
                                    expectedValueInterval:expectedValueIntervalMs
                                                   params:nil];
}
- (void)writeAttributeLocalProgrammingFeaturesWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeLocalProgrammingFeaturesID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeWrongCodeEntryLimitWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeWrongCodeEntryLimitID)
                                             params:params];
}

- (void)writeAttributeWrongCodeEntryLimitWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeWrongCodeEntryLimitWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeWrongCodeEntryLimitWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeWrongCodeEntryLimitID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeUserCodeTemporaryDisableTimeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeUserCodeTemporaryDisableTimeID)
                                             params:params];
}

- (void)writeAttributeUserCodeTemporaryDisableTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeUserCodeTemporaryDisableTimeWithValue:dataValueDictionary
                                        expectedValueInterval:expectedValueIntervalMs
                                                       params:nil];
}
- (void)writeAttributeUserCodeTemporaryDisableTimeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeUserCodeTemporaryDisableTimeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeSendPINOverTheAirWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeSendPINOverTheAirID)
                                             params:params];
}

- (void)writeAttributeSendPINOverTheAirWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeSendPINOverTheAirWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeSendPINOverTheAirWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                          params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeSendPINOverTheAirID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeRequirePINforRemoteOperationWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeRequirePINforRemoteOperationID)
                                             params:params];
}

- (void)writeAttributeRequirePINforRemoteOperationWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeRequirePINforRemoteOperationWithValue:dataValueDictionary
                                        expectedValueInterval:expectedValueIntervalMs
                                                       params:nil];
}
- (void)writeAttributeRequirePINforRemoteOperationWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeRequirePINforRemoteOperationID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeExpiringUserTimeoutWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeExpiringUserTimeoutID)
                                             params:params];
}

- (void)writeAttributeExpiringUserTimeoutWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeExpiringUserTimeoutWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeExpiringUserTimeoutWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterDoorLockID)
                                  attributeId:@(MTRClusterDoorLockAttributeExpiringUserTimeoutID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterDoorLockID)
                                        attributeId:@(MTRClusterDoorLockAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterWindowCovering

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)upOrOpenWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                 completionHandler:(StatusCompletion)completionHandler
{
    [self upOrOpenWithParams:nil
               expectedValues:expectedValues
        expectedValueInterval:expectedValueIntervalMs
            completionHandler:completionHandler];
}
- (void)upOrOpenWithParams:(MTRWindowCoveringClusterUpOrOpenParams * _Nullable)params
            expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
         completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)downOrCloseWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                    completionHandler:(StatusCompletion)completionHandler
{
    [self downOrCloseWithParams:nil
                 expectedValues:expectedValues
          expectedValueInterval:expectedValueIntervalMs
              completionHandler:completionHandler];
}
- (void)downOrCloseWithParams:(MTRWindowCoveringClusterDownOrCloseParams * _Nullable)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)stopMotionWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(StatusCompletion)completionHandler
{
    [self stopMotionWithParams:nil
                expectedValues:expectedValues
         expectedValueInterval:expectedValueIntervalMs
             completionHandler:completionHandler];
}
- (void)stopMotionWithParams:(MTRWindowCoveringClusterStopMotionParams * _Nullable)params
              expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
           completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)goToLiftValueWithParams:(MTRWindowCoveringClusterGoToLiftValueParams *)params
                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)goToLiftPercentageWithParams:(MTRWindowCoveringClusterGoToLiftPercentageParams *)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)goToTiltValueWithParams:(MTRWindowCoveringClusterGoToTiltValueParams *)params
                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)goToTiltPercentageWithParams:(MTRWindowCoveringClusterGoToTiltPercentageParams *)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeTypeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePhysicalClosedLimitLiftWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributePhysicalClosedLimitLiftID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePhysicalClosedLimitTiltWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributePhysicalClosedLimitTiltID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentPositionLiftWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeCurrentPositionLiftID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentPositionTiltWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeCurrentPositionTiltID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNumberOfActuationsLiftWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeNumberOfActuationsLiftID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNumberOfActuationsTiltWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeNumberOfActuationsTiltID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeConfigStatusWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeConfigStatusID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentPositionLiftPercentageWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeCurrentPositionLiftPercentageID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentPositionTiltPercentageWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeCurrentPositionTiltPercentageID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOperationalStatusWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeOperationalStatusID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTargetPositionLiftPercent100thsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeTargetPositionLiftPercent100thsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTargetPositionTiltPercent100thsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeTargetPositionTiltPercent100thsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeEndProductTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeEndProductTypeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentPositionLiftPercent100thsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeCurrentPositionLiftPercent100thsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentPositionTiltPercent100thsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeCurrentPositionTiltPercent100thsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeInstalledOpenLimitLiftWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeInstalledOpenLimitLiftID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeInstalledClosedLimitLiftWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeInstalledClosedLimitLiftID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeInstalledOpenLimitTiltWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeInstalledOpenLimitTiltID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeInstalledClosedLimitTiltWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeInstalledClosedLimitTiltID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeModeID)
                                             params:params];
}

- (void)writeAttributeModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeModeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                             params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterWindowCoveringID)
                                  attributeId:@(MTRClusterWindowCoveringAttributeModeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeSafetyStatusWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeSafetyStatusID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWindowCoveringID)
                                        attributeId:@(MTRClusterWindowCoveringAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterBarrierControl

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)barrierControlGoToPercentWithParams:(MTRBarrierControlClusterBarrierControlGoToPercentParams *)params
                             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                          completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)barrierControlStopWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                           completionHandler:(StatusCompletion)completionHandler
{
    [self barrierControlStopWithParams:nil
                        expectedValues:expectedValues
                 expectedValueInterval:expectedValueIntervalMs
                     completionHandler:completionHandler];
}
- (void)barrierControlStopWithParams:(MTRBarrierControlClusterBarrierControlStopParams * _Nullable)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeBarrierMovingStateWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeBarrierMovingStateID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBarrierSafetyStatusWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeBarrierSafetyStatusID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBarrierCapabilitiesWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeBarrierCapabilitiesID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBarrierOpenEventsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeBarrierOpenEventsID)
                                             params:params];
}

- (void)writeAttributeBarrierOpenEventsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBarrierOpenEventsWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeBarrierOpenEventsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                          params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBarrierControlID)
                                  attributeId:@(MTRClusterBarrierControlAttributeBarrierOpenEventsID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeBarrierCloseEventsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeBarrierCloseEventsID)
                                             params:params];
}

- (void)writeAttributeBarrierCloseEventsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBarrierCloseEventsWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeBarrierCloseEventsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                           params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBarrierControlID)
                                  attributeId:@(MTRClusterBarrierControlAttributeBarrierCloseEventsID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeBarrierCommandOpenEventsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeBarrierCommandOpenEventsID)
                                             params:params];
}

- (void)writeAttributeBarrierCommandOpenEventsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBarrierCommandOpenEventsWithValue:dataValueDictionary
                                    expectedValueInterval:expectedValueIntervalMs
                                                   params:nil];
}
- (void)writeAttributeBarrierCommandOpenEventsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBarrierControlID)
                                  attributeId:@(MTRClusterBarrierControlAttributeBarrierCommandOpenEventsID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeBarrierCommandCloseEventsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeBarrierCommandCloseEventsID)
                                             params:params];
}

- (void)writeAttributeBarrierCommandCloseEventsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBarrierCommandCloseEventsWithValue:dataValueDictionary
                                     expectedValueInterval:expectedValueIntervalMs
                                                    params:nil];
}
- (void)writeAttributeBarrierCommandCloseEventsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                  params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBarrierControlID)
                                  attributeId:@(MTRClusterBarrierControlAttributeBarrierCommandCloseEventsID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeBarrierOpenPeriodWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeBarrierOpenPeriodID)
                                             params:params];
}

- (void)writeAttributeBarrierOpenPeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBarrierOpenPeriodWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeBarrierOpenPeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                          params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBarrierControlID)
                                  attributeId:@(MTRClusterBarrierControlAttributeBarrierOpenPeriodID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeBarrierClosePeriodWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeBarrierClosePeriodID)
                                             params:params];
}

- (void)writeAttributeBarrierClosePeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBarrierClosePeriodWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeBarrierClosePeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                           params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBarrierControlID)
                                  attributeId:@(MTRClusterBarrierControlAttributeBarrierClosePeriodID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeBarrierPositionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeBarrierPositionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBarrierControlID)
                                        attributeId:@(MTRClusterBarrierControlAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterPumpConfigurationAndControl

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeMaxPressureWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeMaxPressureID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxSpeedWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeMaxSpeedID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxFlowWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeMaxFlowID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinConstPressureWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeMinConstPressureID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxConstPressureWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeMaxConstPressureID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinCompPressureWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeMinCompPressureID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxCompPressureWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeMaxCompPressureID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinConstSpeedWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeMinConstSpeedID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxConstSpeedWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeMaxConstSpeedID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinConstFlowWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeMinConstFlowID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxConstFlowWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeMaxConstFlowID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinConstTempWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeMinConstTempID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxConstTempWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeMaxConstTempID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePumpStatusWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributePumpStatusID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeEffectiveOperationModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeEffectiveOperationModeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeEffectiveControlModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeEffectiveControlModeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCapacityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeCapacityID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSpeedWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeSpeedID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLifetimeRunningHoursWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeLifetimeRunningHoursID)
                                             params:params];
}

- (void)writeAttributeLifetimeRunningHoursWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLifetimeRunningHoursWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeLifetimeRunningHoursWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                             params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                  attributeId:@(MTRClusterPumpConfigurationAndControlAttributeLifetimeRunningHoursID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributePowerWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributePowerID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLifetimeEnergyConsumedWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeLifetimeEnergyConsumedID)
                                             params:params];
}

- (void)writeAttributeLifetimeEnergyConsumedWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLifetimeEnergyConsumedWithValue:dataValueDictionary
                                  expectedValueInterval:expectedValueIntervalMs
                                                 params:nil];
}
- (void)writeAttributeLifetimeEnergyConsumedWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                  attributeId:@(MTRClusterPumpConfigurationAndControlAttributeLifetimeEnergyConsumedID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOperationModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeOperationModeID)
                                             params:params];
}

- (void)writeAttributeOperationModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOperationModeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOperationModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                  attributeId:@(MTRClusterPumpConfigurationAndControlAttributeOperationModeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeControlModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeControlModeID)
                                             params:params];
}

- (void)writeAttributeControlModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeControlModeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeControlModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                  attributeId:@(MTRClusterPumpConfigurationAndControlAttributeControlModeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPumpConfigurationAndControlID)
                                        attributeId:@(MTRClusterPumpConfigurationAndControlAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterThermostat

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)setpointRaiseLowerWithParams:(MTRThermostatClusterSetpointRaiseLowerParams *)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)setWeeklyScheduleWithParams:(MTRThermostatClusterSetWeeklyScheduleParams *)params
                     expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                  completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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.
                                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();
                    }
                }

                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];
}

- (void)getWeeklyScheduleWithParams:(MTRThermostatClusterGetWeeklyScheduleParams *)params
                     expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                  completionHandler:(void (^)(MTRThermostatClusterGetWeeklyScheduleResponseParams * _Nullable data,
                                        NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)clearWeeklyScheduleWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                            completionHandler:(StatusCompletion)completionHandler
{
    [self clearWeeklyScheduleWithParams:nil
                         expectedValues:expectedValues
                  expectedValueInterval:expectedValueIntervalMs
                      completionHandler:completionHandler];
}
- (void)clearWeeklyScheduleWithParams:(MTRThermostatClusterClearWeeklyScheduleParams * _Nullable)params
                       expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                    completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeLocalTemperatureWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeLocalTemperatureID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOutdoorTemperatureWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeOutdoorTemperatureID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOccupancyWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeOccupancyID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAbsMinHeatSetpointLimitWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeAbsMinHeatSetpointLimitID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAbsMaxHeatSetpointLimitWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeAbsMaxHeatSetpointLimitID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAbsMinCoolSetpointLimitWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeAbsMinCoolSetpointLimitID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAbsMaxCoolSetpointLimitWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeAbsMaxCoolSetpointLimitID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePICoolingDemandWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributePICoolingDemandID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePIHeatingDemandWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributePIHeatingDemandID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeHVACSystemTypeConfigurationWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeHVACSystemTypeConfigurationID)
                                             params:params];
}

- (void)writeAttributeHVACSystemTypeConfigurationWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeHVACSystemTypeConfigurationWithValue:dataValueDictionary
                                       expectedValueInterval:expectedValueIntervalMs
                                                      params:nil];
}
- (void)writeAttributeHVACSystemTypeConfigurationWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeHVACSystemTypeConfigurationID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeLocalTemperatureCalibrationWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeLocalTemperatureCalibrationID)
                                             params:params];
}

- (void)writeAttributeLocalTemperatureCalibrationWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLocalTemperatureCalibrationWithValue:dataValueDictionary
                                       expectedValueInterval:expectedValueIntervalMs
                                                      params:nil];
}
- (void)writeAttributeLocalTemperatureCalibrationWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeLocalTemperatureCalibrationID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOccupiedCoolingSetpointWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeOccupiedCoolingSetpointID)
                                             params:params];
}

- (void)writeAttributeOccupiedCoolingSetpointWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOccupiedCoolingSetpointWithValue:dataValueDictionary
                                   expectedValueInterval:expectedValueIntervalMs
                                                  params:nil];
}
- (void)writeAttributeOccupiedCoolingSetpointWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeOccupiedCoolingSetpointID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOccupiedHeatingSetpointWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeOccupiedHeatingSetpointID)
                                             params:params];
}

- (void)writeAttributeOccupiedHeatingSetpointWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOccupiedHeatingSetpointWithValue:dataValueDictionary
                                   expectedValueInterval:expectedValueIntervalMs
                                                  params:nil];
}
- (void)writeAttributeOccupiedHeatingSetpointWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeOccupiedHeatingSetpointID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeUnoccupiedCoolingSetpointWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeUnoccupiedCoolingSetpointID)
                                             params:params];
}

- (void)writeAttributeUnoccupiedCoolingSetpointWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeUnoccupiedCoolingSetpointWithValue:dataValueDictionary
                                     expectedValueInterval:expectedValueIntervalMs
                                                    params:nil];
}
- (void)writeAttributeUnoccupiedCoolingSetpointWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                  params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeUnoccupiedCoolingSetpointID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeUnoccupiedHeatingSetpointWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeUnoccupiedHeatingSetpointID)
                                             params:params];
}

- (void)writeAttributeUnoccupiedHeatingSetpointWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeUnoccupiedHeatingSetpointWithValue:dataValueDictionary
                                     expectedValueInterval:expectedValueIntervalMs
                                                    params:nil];
}
- (void)writeAttributeUnoccupiedHeatingSetpointWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                  params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeUnoccupiedHeatingSetpointID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeMinHeatSetpointLimitWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeMinHeatSetpointLimitID)
                                             params:params];
}

- (void)writeAttributeMinHeatSetpointLimitWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeMinHeatSetpointLimitWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeMinHeatSetpointLimitWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                             params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeMinHeatSetpointLimitID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxHeatSetpointLimitWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeMaxHeatSetpointLimitID)
                                             params:params];
}

- (void)writeAttributeMaxHeatSetpointLimitWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeMaxHeatSetpointLimitWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeMaxHeatSetpointLimitWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                             params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeMaxHeatSetpointLimitID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeMinCoolSetpointLimitWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeMinCoolSetpointLimitID)
                                             params:params];
}

- (void)writeAttributeMinCoolSetpointLimitWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeMinCoolSetpointLimitWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeMinCoolSetpointLimitWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                             params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeMinCoolSetpointLimitID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxCoolSetpointLimitWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeMaxCoolSetpointLimitID)
                                             params:params];
}

- (void)writeAttributeMaxCoolSetpointLimitWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeMaxCoolSetpointLimitWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeMaxCoolSetpointLimitWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                             params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeMaxCoolSetpointLimitID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeMinSetpointDeadBandWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeMinSetpointDeadBandID)
                                             params:params];
}

- (void)writeAttributeMinSetpointDeadBandWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeMinSetpointDeadBandWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeMinSetpointDeadBandWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeMinSetpointDeadBandID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeRemoteSensingWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeRemoteSensingID)
                                             params:params];
}

- (void)writeAttributeRemoteSensingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeRemoteSensingWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeRemoteSensingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeRemoteSensingID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeControlSequenceOfOperationWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeControlSequenceOfOperationID)
                                             params:params];
}

- (void)writeAttributeControlSequenceOfOperationWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeControlSequenceOfOperationWithValue:dataValueDictionary
                                      expectedValueInterval:expectedValueIntervalMs
                                                     params:nil];
}
- (void)writeAttributeControlSequenceOfOperationWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                   params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeControlSequenceOfOperationID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeSystemModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeSystemModeID)
                                             params:params];
}

- (void)writeAttributeSystemModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeSystemModeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeSystemModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                   params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeSystemModeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeThermostatRunningModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeThermostatRunningModeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeStartOfWeekWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeStartOfWeekID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNumberOfWeeklyTransitionsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeNumberOfWeeklyTransitionsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNumberOfDailyTransitionsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeNumberOfDailyTransitionsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTemperatureSetpointHoldWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeTemperatureSetpointHoldID)
                                             params:params];
}

- (void)writeAttributeTemperatureSetpointHoldWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeTemperatureSetpointHoldWithValue:dataValueDictionary
                                   expectedValueInterval:expectedValueIntervalMs
                                                  params:nil];
}
- (void)writeAttributeTemperatureSetpointHoldWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeTemperatureSetpointHoldID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeTemperatureSetpointHoldDurationWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeTemperatureSetpointHoldDurationID)
                                             params:params];
}

- (void)writeAttributeTemperatureSetpointHoldDurationWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeTemperatureSetpointHoldDurationWithValue:dataValueDictionary
                                           expectedValueInterval:expectedValueIntervalMs
                                                          params:nil];
}
- (void)writeAttributeTemperatureSetpointHoldDurationWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                        params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeTemperatureSetpointHoldDurationID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeThermostatProgrammingOperationModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeThermostatProgrammingOperationModeID)
                                             params:params];
}

- (void)writeAttributeThermostatProgrammingOperationModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeThermostatProgrammingOperationModeWithValue:dataValueDictionary
                                              expectedValueInterval:expectedValueIntervalMs
                                                             params:nil];
}
- (void)writeAttributeThermostatProgrammingOperationModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                           params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeThermostatProgrammingOperationModeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeThermostatRunningStateWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeThermostatRunningStateID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSetpointChangeSourceWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeSetpointChangeSourceID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSetpointChangeAmountWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeSetpointChangeAmountID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSetpointChangeSourceTimestampWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeSetpointChangeSourceTimestampID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOccupiedSetbackWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeOccupiedSetbackID)
                                             params:params];
}

- (void)writeAttributeOccupiedSetbackWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOccupiedSetbackWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOccupiedSetbackWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                        params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeOccupiedSetbackID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOccupiedSetbackMinWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeOccupiedSetbackMinID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOccupiedSetbackMaxWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeOccupiedSetbackMaxID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeUnoccupiedSetbackWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeUnoccupiedSetbackID)
                                             params:params];
}

- (void)writeAttributeUnoccupiedSetbackWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeUnoccupiedSetbackWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeUnoccupiedSetbackWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                          params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeUnoccupiedSetbackID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeUnoccupiedSetbackMinWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeUnoccupiedSetbackMinID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeUnoccupiedSetbackMaxWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeUnoccupiedSetbackMaxID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeEmergencyHeatDeltaWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeEmergencyHeatDeltaID)
                                             params:params];
}

- (void)writeAttributeEmergencyHeatDeltaWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeEmergencyHeatDeltaWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeEmergencyHeatDeltaWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                           params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeEmergencyHeatDeltaID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeACTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeACTypeID)
                                             params:params];
}

- (void)writeAttributeACTypeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeACTypeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeACTypeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeACTypeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeACCapacityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeACCapacityID)
                                             params:params];
}

- (void)writeAttributeACCapacityWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeACCapacityWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeACCapacityWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                   params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeACCapacityID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeACRefrigerantTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeACRefrigerantTypeID)
                                             params:params];
}

- (void)writeAttributeACRefrigerantTypeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeACRefrigerantTypeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeACRefrigerantTypeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                          params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeACRefrigerantTypeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeACCompressorTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeACCompressorTypeID)
                                             params:params];
}

- (void)writeAttributeACCompressorTypeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeACCompressorTypeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeACCompressorTypeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                         params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeACCompressorTypeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeACErrorCodeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeACErrorCodeID)
                                             params:params];
}

- (void)writeAttributeACErrorCodeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeACErrorCodeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeACErrorCodeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeACErrorCodeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeACLouverPositionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeACLouverPositionID)
                                             params:params];
}

- (void)writeAttributeACLouverPositionWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeACLouverPositionWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeACLouverPositionWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                         params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeACLouverPositionID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeACCoilTemperatureWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeACCoilTemperatureID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeACCapacityformatWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeACCapacityformatID)
                                             params:params];
}

- (void)writeAttributeACCapacityformatWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeACCapacityformatWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeACCapacityformatWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                         params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatID)
                                  attributeId:@(MTRClusterThermostatAttributeACCapacityformatID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatID)
                                        attributeId:@(MTRClusterThermostatAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterFanControl

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeFanModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeFanModeID)
                                             params:params];
}

- (void)writeAttributeFanModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeFanModeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeFanModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterFanControlID)
                                  attributeId:@(MTRClusterFanControlAttributeFanModeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeFanModeSequenceWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeFanModeSequenceID)
                                             params:params];
}

- (void)writeAttributeFanModeSequenceWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeFanModeSequenceWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeFanModeSequenceWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                        params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterFanControlID)
                                  attributeId:@(MTRClusterFanControlAttributeFanModeSequenceID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributePercentSettingWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributePercentSettingID)
                                             params:params];
}

- (void)writeAttributePercentSettingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributePercentSettingWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributePercentSettingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterFanControlID)
                                  attributeId:@(MTRClusterFanControlAttributePercentSettingID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributePercentCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributePercentCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSpeedMaxWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeSpeedMaxID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSpeedSettingWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeSpeedSettingID)
                                             params:params];
}

- (void)writeAttributeSpeedSettingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeSpeedSettingWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeSpeedSettingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterFanControlID)
                                  attributeId:@(MTRClusterFanControlAttributeSpeedSettingID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeSpeedCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeSpeedCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRockSupportWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeRockSupportID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRockSettingWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeRockSettingID)
                                             params:params];
}

- (void)writeAttributeRockSettingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeRockSettingWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeRockSettingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterFanControlID)
                                  attributeId:@(MTRClusterFanControlAttributeRockSettingID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeWindSupportWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeWindSupportID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeWindSettingWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeWindSettingID)
                                             params:params];
}

- (void)writeAttributeWindSettingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeWindSettingWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeWindSettingWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterFanControlID)
                                  attributeId:@(MTRClusterFanControlAttributeWindSettingID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFanControlID)
                                        attributeId:@(MTRClusterFanControlAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterThermostatUserInterfaceConfiguration

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeTemperatureDisplayModeWithParams:(MTRReadParams * _Nullable)params
{
    return
        [self.device readAttributeWithEndpointId:@(_endpoint)
                                       clusterId:@(MTRClusterThermostatUserInterfaceConfigurationID)
                                     attributeId:@(MTRClusterThermostatUserInterfaceConfigurationAttributeTemperatureDisplayModeID)
                                          params:params];
}

- (void)writeAttributeTemperatureDisplayModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeTemperatureDisplayModeWithValue:dataValueDictionary
                                  expectedValueInterval:expectedValueIntervalMs
                                                 params:nil];
}
- (void)writeAttributeTemperatureDisplayModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatUserInterfaceConfigurationID)
                                  attributeId:@(MTRClusterThermostatUserInterfaceConfigurationAttributeTemperatureDisplayModeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeKeypadLockoutWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatUserInterfaceConfigurationID)
                                        attributeId:@(MTRClusterThermostatUserInterfaceConfigurationAttributeKeypadLockoutID)
                                             params:params];
}

- (void)writeAttributeKeypadLockoutWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeKeypadLockoutWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeKeypadLockoutWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterThermostatUserInterfaceConfigurationID)
                                  attributeId:@(MTRClusterThermostatUserInterfaceConfigurationAttributeKeypadLockoutID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeScheduleProgrammingVisibilityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device
        readAttributeWithEndpointId:@(_endpoint)
                          clusterId:@(MTRClusterThermostatUserInterfaceConfigurationID)
                        attributeId:@(MTRClusterThermostatUserInterfaceConfigurationAttributeScheduleProgrammingVisibilityID)
                             params:params];
}

- (void)writeAttributeScheduleProgrammingVisibilityWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeScheduleProgrammingVisibilityWithValue:dataValueDictionary
                                         expectedValueInterval:expectedValueIntervalMs
                                                        params:nil];
}
- (void)writeAttributeScheduleProgrammingVisibilityWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device
        writeAttributeWithEndpointId:@(_endpoint)
                           clusterId:@(MTRClusterThermostatUserInterfaceConfigurationID)
                         attributeId:@(MTRClusterThermostatUserInterfaceConfigurationAttributeScheduleProgrammingVisibilityID)
                               value:dataValueDictionary
               expectedValueInterval:expectedValueIntervalMs
                   timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatUserInterfaceConfigurationID)
                                        attributeId:@(MTRClusterThermostatUserInterfaceConfigurationAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatUserInterfaceConfigurationID)
                                        attributeId:@(MTRClusterThermostatUserInterfaceConfigurationAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatUserInterfaceConfigurationID)
                                        attributeId:@(MTRClusterThermostatUserInterfaceConfigurationAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatUserInterfaceConfigurationID)
                                        attributeId:@(MTRClusterThermostatUserInterfaceConfigurationAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterThermostatUserInterfaceConfigurationID)
                                        attributeId:@(MTRClusterThermostatUserInterfaceConfigurationAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterColorControl

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)moveToHueWithParams:(MTRColorControlClusterMoveToHueParams *)params
             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
          completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)moveHueWithParams:(MTRColorControlClusterMoveHueParams *)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)stepHueWithParams:(MTRColorControlClusterStepHueParams *)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)moveToSaturationWithParams:(MTRColorControlClusterMoveToSaturationParams *)params
                    expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                 completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)moveSaturationWithParams:(MTRColorControlClusterMoveSaturationParams *)params
                  expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
               completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)stepSaturationWithParams:(MTRColorControlClusterStepSaturationParams *)params
                  expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
               completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)moveToHueAndSaturationWithParams:(MTRColorControlClusterMoveToHueAndSaturationParams *)params
                          expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                       completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)moveToColorWithParams:(MTRColorControlClusterMoveToColorParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)moveColorWithParams:(MTRColorControlClusterMoveColorParams *)params
             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
          completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)stepColorWithParams:(MTRColorControlClusterStepColorParams *)params
             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
          completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)moveToColorTemperatureWithParams:(MTRColorControlClusterMoveToColorTemperatureParams *)params
                          expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                       completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)enhancedMoveToHueWithParams:(MTRColorControlClusterEnhancedMoveToHueParams *)params
                     expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                  completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)enhancedMoveHueWithParams:(MTRColorControlClusterEnhancedMoveHueParams *)params
                   expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)enhancedStepHueWithParams:(MTRColorControlClusterEnhancedStepHueParams *)params
                   expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)enhancedMoveToHueAndSaturationWithParams:(MTRColorControlClusterEnhancedMoveToHueAndSaturationParams *)params
                                  expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)colorLoopSetWithParams:(MTRColorControlClusterColorLoopSetParams *)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)stopMoveStepWithParams:(MTRColorControlClusterStopMoveStepParams *)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)moveColorTemperatureWithParams:(MTRColorControlClusterMoveColorTemperatureParams *)params
                        expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                     completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)stepColorTemperatureWithParams:(MTRColorControlClusterStepColorTemperatureParams *)params
                        expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                     completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentHueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeCurrentHueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentSaturationWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeCurrentSaturationID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRemainingTimeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeRemainingTimeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentXWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeCurrentXID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentYWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeCurrentYID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDriftCompensationWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeDriftCompensationID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCompensationTextWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeCompensationTextID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeColorTemperatureWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorTemperatureID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeColorModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorModeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOptionsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeOptionsID)
                                             params:params];
}

- (void)writeAttributeOptionsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOptionsWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOptionsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterColorControlID)
                                  attributeId:@(MTRClusterColorControlAttributeOptionsID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNumberOfPrimariesWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeNumberOfPrimariesID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary1XWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary1XID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary1YWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary1YID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary1IntensityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary1IntensityID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary2XWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary2XID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary2YWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary2YID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary2IntensityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary2IntensityID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary3XWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary3XID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary3YWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary3YID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary3IntensityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary3IntensityID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary4XWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary4XID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary4YWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary4YID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary4IntensityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary4IntensityID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary5XWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary5XID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary5YWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary5YID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary5IntensityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary5IntensityID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary6XWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary6XID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary6YWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary6YID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePrimary6IntensityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributePrimary6IntensityID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeWhitePointXWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeWhitePointXID)
                                             params:params];
}

- (void)writeAttributeWhitePointXWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeWhitePointXWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeWhitePointXWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterColorControlID)
                                  attributeId:@(MTRClusterColorControlAttributeWhitePointXID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeWhitePointYWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeWhitePointYID)
                                             params:params];
}

- (void)writeAttributeWhitePointYWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeWhitePointYWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeWhitePointYWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterColorControlID)
                                  attributeId:@(MTRClusterColorControlAttributeWhitePointYID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeColorPointRXWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorPointRXID)
                                             params:params];
}

- (void)writeAttributeColorPointRXWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeColorPointRXWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeColorPointRXWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterColorControlID)
                                  attributeId:@(MTRClusterColorControlAttributeColorPointRXID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeColorPointRYWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorPointRYID)
                                             params:params];
}

- (void)writeAttributeColorPointRYWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeColorPointRYWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeColorPointRYWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterColorControlID)
                                  attributeId:@(MTRClusterColorControlAttributeColorPointRYID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeColorPointRIntensityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorPointRIntensityID)
                                             params:params];
}

- (void)writeAttributeColorPointRIntensityWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeColorPointRIntensityWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeColorPointRIntensityWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                             params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterColorControlID)
                                  attributeId:@(MTRClusterColorControlAttributeColorPointRIntensityID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeColorPointGXWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorPointGXID)
                                             params:params];
}

- (void)writeAttributeColorPointGXWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeColorPointGXWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeColorPointGXWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterColorControlID)
                                  attributeId:@(MTRClusterColorControlAttributeColorPointGXID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeColorPointGYWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorPointGYID)
                                             params:params];
}

- (void)writeAttributeColorPointGYWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeColorPointGYWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeColorPointGYWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterColorControlID)
                                  attributeId:@(MTRClusterColorControlAttributeColorPointGYID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeColorPointGIntensityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorPointGIntensityID)
                                             params:params];
}

- (void)writeAttributeColorPointGIntensityWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeColorPointGIntensityWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeColorPointGIntensityWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                             params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterColorControlID)
                                  attributeId:@(MTRClusterColorControlAttributeColorPointGIntensityID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeColorPointBXWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorPointBXID)
                                             params:params];
}

- (void)writeAttributeColorPointBXWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeColorPointBXWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeColorPointBXWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterColorControlID)
                                  attributeId:@(MTRClusterColorControlAttributeColorPointBXID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeColorPointBYWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorPointBYID)
                                             params:params];
}

- (void)writeAttributeColorPointBYWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeColorPointBYWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeColorPointBYWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterColorControlID)
                                  attributeId:@(MTRClusterColorControlAttributeColorPointBYID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeColorPointBIntensityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorPointBIntensityID)
                                             params:params];
}

- (void)writeAttributeColorPointBIntensityWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeColorPointBIntensityWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeColorPointBIntensityWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                             params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterColorControlID)
                                  attributeId:@(MTRClusterColorControlAttributeColorPointBIntensityID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeEnhancedCurrentHueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeEnhancedCurrentHueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeEnhancedColorModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeEnhancedColorModeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeColorLoopActiveWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorLoopActiveID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeColorLoopDirectionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorLoopDirectionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeColorLoopTimeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorLoopTimeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeColorLoopStartEnhancedHueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorLoopStartEnhancedHueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeColorLoopStoredEnhancedHueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorLoopStoredEnhancedHueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeColorCapabilitiesWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorCapabilitiesID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeColorTempPhysicalMinMiredsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorTempPhysicalMinMiredsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeColorTempPhysicalMaxMiredsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeColorTempPhysicalMaxMiredsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCoupleColorTempToLevelMinMiredsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeCoupleColorTempToLevelMinMiredsID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeStartUpColorTemperatureMiredsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeStartUpColorTemperatureMiredsID)
                                             params:params];
}

- (void)writeAttributeStartUpColorTemperatureMiredsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeStartUpColorTemperatureMiredsWithValue:dataValueDictionary
                                         expectedValueInterval:expectedValueIntervalMs
                                                        params:nil];
}
- (void)writeAttributeStartUpColorTemperatureMiredsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterColorControlID)
                                  attributeId:@(MTRClusterColorControlAttributeStartUpColorTemperatureMiredsID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterColorControlID)
                                        attributeId:@(MTRClusterColorControlAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterBallastConfiguration

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributePhysicalMinLevelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributePhysicalMinLevelID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePhysicalMaxLevelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributePhysicalMaxLevelID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeBallastStatusWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeBallastStatusID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinLevelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeMinLevelID)
                                             params:params];
}

- (void)writeAttributeMinLevelWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeMinLevelWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeMinLevelWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBallastConfigurationID)
                                  attributeId:@(MTRClusterBallastConfigurationAttributeMinLevelID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxLevelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeMaxLevelID)
                                             params:params];
}

- (void)writeAttributeMaxLevelWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeMaxLevelWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeMaxLevelWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBallastConfigurationID)
                                  attributeId:@(MTRClusterBallastConfigurationAttributeMaxLevelID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeIntrinsicBalanceFactorWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeIntrinsicBalanceFactorID)
                                             params:params];
}

- (void)writeAttributeIntrinsicBalanceFactorWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeIntrinsicBalanceFactorWithValue:dataValueDictionary
                                  expectedValueInterval:expectedValueIntervalMs
                                                 params:nil];
}
- (void)writeAttributeIntrinsicBalanceFactorWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBallastConfigurationID)
                                  attributeId:@(MTRClusterBallastConfigurationAttributeIntrinsicBalanceFactorID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeBallastFactorAdjustmentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeBallastFactorAdjustmentID)
                                             params:params];
}

- (void)writeAttributeBallastFactorAdjustmentWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBallastFactorAdjustmentWithValue:dataValueDictionary
                                   expectedValueInterval:expectedValueIntervalMs
                                                  params:nil];
}
- (void)writeAttributeBallastFactorAdjustmentWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBallastConfigurationID)
                                  attributeId:@(MTRClusterBallastConfigurationAttributeBallastFactorAdjustmentID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeLampQuantityWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeLampQuantityID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLampTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeLampTypeID)
                                             params:params];
}

- (void)writeAttributeLampTypeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLampTypeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeLampTypeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBallastConfigurationID)
                                  attributeId:@(MTRClusterBallastConfigurationAttributeLampTypeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeLampManufacturerWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeLampManufacturerID)
                                             params:params];
}

- (void)writeAttributeLampManufacturerWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLampManufacturerWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeLampManufacturerWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                         params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBallastConfigurationID)
                                  attributeId:@(MTRClusterBallastConfigurationAttributeLampManufacturerID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeLampRatedHoursWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeLampRatedHoursID)
                                             params:params];
}

- (void)writeAttributeLampRatedHoursWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLampRatedHoursWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeLampRatedHoursWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBallastConfigurationID)
                                  attributeId:@(MTRClusterBallastConfigurationAttributeLampRatedHoursID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeLampBurnHoursWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeLampBurnHoursID)
                                             params:params];
}

- (void)writeAttributeLampBurnHoursWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLampBurnHoursWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeLampBurnHoursWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBallastConfigurationID)
                                  attributeId:@(MTRClusterBallastConfigurationAttributeLampBurnHoursID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeLampAlarmModeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeLampAlarmModeID)
                                             params:params];
}

- (void)writeAttributeLampAlarmModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLampAlarmModeWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeLampAlarmModeWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBallastConfigurationID)
                                  attributeId:@(MTRClusterBallastConfigurationAttributeLampAlarmModeID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeLampBurnHoursTripPointWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeLampBurnHoursTripPointID)
                                             params:params];
}

- (void)writeAttributeLampBurnHoursTripPointWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLampBurnHoursTripPointWithValue:dataValueDictionary
                                  expectedValueInterval:expectedValueIntervalMs
                                                 params:nil];
}
- (void)writeAttributeLampBurnHoursTripPointWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterBallastConfigurationID)
                                  attributeId:@(MTRClusterBallastConfigurationAttributeLampBurnHoursTripPointID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterBallastConfigurationID)
                                        attributeId:@(MTRClusterBallastConfigurationAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterIlluminanceMeasurement

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIlluminanceMeasurementID)
                                        attributeId:@(MTRClusterIlluminanceMeasurementAttributeMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIlluminanceMeasurementID)
                                        attributeId:@(MTRClusterIlluminanceMeasurementAttributeMinMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIlluminanceMeasurementID)
                                        attributeId:@(MTRClusterIlluminanceMeasurementAttributeMaxMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeToleranceWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIlluminanceMeasurementID)
                                        attributeId:@(MTRClusterIlluminanceMeasurementAttributeToleranceID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLightSensorTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIlluminanceMeasurementID)
                                        attributeId:@(MTRClusterIlluminanceMeasurementAttributeLightSensorTypeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIlluminanceMeasurementID)
                                        attributeId:@(MTRClusterIlluminanceMeasurementAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIlluminanceMeasurementID)
                                        attributeId:@(MTRClusterIlluminanceMeasurementAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIlluminanceMeasurementID)
                                        attributeId:@(MTRClusterIlluminanceMeasurementAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIlluminanceMeasurementID)
                                        attributeId:@(MTRClusterIlluminanceMeasurementAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterIlluminanceMeasurementID)
                                        attributeId:@(MTRClusterIlluminanceMeasurementAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterTemperatureMeasurement

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTemperatureMeasurementID)
                                        attributeId:@(MTRClusterTemperatureMeasurementAttributeMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTemperatureMeasurementID)
                                        attributeId:@(MTRClusterTemperatureMeasurementAttributeMinMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTemperatureMeasurementID)
                                        attributeId:@(MTRClusterTemperatureMeasurementAttributeMaxMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeToleranceWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTemperatureMeasurementID)
                                        attributeId:@(MTRClusterTemperatureMeasurementAttributeToleranceID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTemperatureMeasurementID)
                                        attributeId:@(MTRClusterTemperatureMeasurementAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTemperatureMeasurementID)
                                        attributeId:@(MTRClusterTemperatureMeasurementAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTemperatureMeasurementID)
                                        attributeId:@(MTRClusterTemperatureMeasurementAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTemperatureMeasurementID)
                                        attributeId:@(MTRClusterTemperatureMeasurementAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTemperatureMeasurementID)
                                        attributeId:@(MTRClusterTemperatureMeasurementAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterPressureMeasurement

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeMinMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeMaxMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeToleranceWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeToleranceID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeScaledValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeScaledValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinScaledValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeMinScaledValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxScaledValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeMaxScaledValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeScaledToleranceWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeScaledToleranceID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeScaleWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeScaleID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterPressureMeasurementID)
                                        attributeId:@(MTRClusterPressureMeasurementAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterFlowMeasurement

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFlowMeasurementID)
                                        attributeId:@(MTRClusterFlowMeasurementAttributeMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFlowMeasurementID)
                                        attributeId:@(MTRClusterFlowMeasurementAttributeMinMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFlowMeasurementID)
                                        attributeId:@(MTRClusterFlowMeasurementAttributeMaxMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeToleranceWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFlowMeasurementID)
                                        attributeId:@(MTRClusterFlowMeasurementAttributeToleranceID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFlowMeasurementID)
                                        attributeId:@(MTRClusterFlowMeasurementAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFlowMeasurementID)
                                        attributeId:@(MTRClusterFlowMeasurementAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFlowMeasurementID)
                                        attributeId:@(MTRClusterFlowMeasurementAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFlowMeasurementID)
                                        attributeId:@(MTRClusterFlowMeasurementAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterFlowMeasurementID)
                                        attributeId:@(MTRClusterFlowMeasurementAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterRelativeHumidityMeasurement

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterRelativeHumidityMeasurementID)
                                        attributeId:@(MTRClusterRelativeHumidityMeasurementAttributeMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMinMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterRelativeHumidityMeasurementID)
                                        attributeId:@(MTRClusterRelativeHumidityMeasurementAttributeMinMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMaxMeasuredValueWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterRelativeHumidityMeasurementID)
                                        attributeId:@(MTRClusterRelativeHumidityMeasurementAttributeMaxMeasuredValueID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeToleranceWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterRelativeHumidityMeasurementID)
                                        attributeId:@(MTRClusterRelativeHumidityMeasurementAttributeToleranceID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterRelativeHumidityMeasurementID)
                                        attributeId:@(MTRClusterRelativeHumidityMeasurementAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterRelativeHumidityMeasurementID)
                                        attributeId:@(MTRClusterRelativeHumidityMeasurementAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterRelativeHumidityMeasurementID)
                                        attributeId:@(MTRClusterRelativeHumidityMeasurementAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterRelativeHumidityMeasurementID)
                                        attributeId:@(MTRClusterRelativeHumidityMeasurementAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterRelativeHumidityMeasurementID)
                                        attributeId:@(MTRClusterRelativeHumidityMeasurementAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterOccupancySensing

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeOccupancyWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributeOccupancyID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOccupancySensorTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributeOccupancySensorTypeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOccupancySensorTypeBitmapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributeOccupancySensorTypeBitmapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePirOccupiedToUnoccupiedDelayWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributePirOccupiedToUnoccupiedDelayID)
                                             params:params];
}

- (void)writeAttributePirOccupiedToUnoccupiedDelayWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributePirOccupiedToUnoccupiedDelayWithValue:dataValueDictionary
                                        expectedValueInterval:expectedValueIntervalMs
                                                       params:nil];
}
- (void)writeAttributePirOccupiedToUnoccupiedDelayWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOccupancySensingID)
                                  attributeId:@(MTRClusterOccupancySensingAttributePirOccupiedToUnoccupiedDelayID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributePirUnoccupiedToOccupiedDelayWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributePirUnoccupiedToOccupiedDelayID)
                                             params:params];
}

- (void)writeAttributePirUnoccupiedToOccupiedDelayWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributePirUnoccupiedToOccupiedDelayWithValue:dataValueDictionary
                                        expectedValueInterval:expectedValueIntervalMs
                                                       params:nil];
}
- (void)writeAttributePirUnoccupiedToOccupiedDelayWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOccupancySensingID)
                                  attributeId:@(MTRClusterOccupancySensingAttributePirUnoccupiedToOccupiedDelayID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributePirUnoccupiedToOccupiedThresholdWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributePirUnoccupiedToOccupiedThresholdID)
                                             params:params];
}

- (void)writeAttributePirUnoccupiedToOccupiedThresholdWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributePirUnoccupiedToOccupiedThresholdWithValue:dataValueDictionary
                                            expectedValueInterval:expectedValueIntervalMs
                                                           params:nil];
}
- (void)writeAttributePirUnoccupiedToOccupiedThresholdWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                         params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOccupancySensingID)
                                  attributeId:@(MTRClusterOccupancySensingAttributePirUnoccupiedToOccupiedThresholdID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributeUltrasonicOccupiedToUnoccupiedDelayID)
                                             params:params];
}

- (void)writeAttributeUltrasonicOccupiedToUnoccupiedDelayWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeUltrasonicOccupiedToUnoccupiedDelayWithValue:dataValueDictionary
                                               expectedValueInterval:expectedValueIntervalMs
                                                              params:nil];
}
- (void)writeAttributeUltrasonicOccupiedToUnoccupiedDelayWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOccupancySensingID)
                                  attributeId:@(MTRClusterOccupancySensingAttributeUltrasonicOccupiedToUnoccupiedDelayID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributeUltrasonicUnoccupiedToOccupiedDelayID)
                                             params:params];
}

- (void)writeAttributeUltrasonicUnoccupiedToOccupiedDelayWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeUltrasonicUnoccupiedToOccupiedDelayWithValue:dataValueDictionary
                                               expectedValueInterval:expectedValueIntervalMs
                                                              params:nil];
}
- (void)writeAttributeUltrasonicUnoccupiedToOccupiedDelayWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOccupancySensingID)
                                  attributeId:@(MTRClusterOccupancySensingAttributeUltrasonicUnoccupiedToOccupiedDelayID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributeUltrasonicUnoccupiedToOccupiedThresholdID)
                                             params:params];
}

- (void)writeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithValue:dataValueDictionary
                                                   expectedValueInterval:expectedValueIntervalMs
                                                                  params:nil];
}
- (void)writeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOccupancySensingID)
                                  attributeId:@(MTRClusterOccupancySensingAttributeUltrasonicUnoccupiedToOccupiedThresholdID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributePhysicalContactOccupiedToUnoccupiedDelayID)
                                             params:params];
}

- (void)writeAttributePhysicalContactOccupiedToUnoccupiedDelayWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributePhysicalContactOccupiedToUnoccupiedDelayWithValue:dataValueDictionary
                                                    expectedValueInterval:expectedValueIntervalMs
                                                                   params:nil];
}
- (void)writeAttributePhysicalContactOccupiedToUnoccupiedDelayWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOccupancySensingID)
                                  attributeId:@(MTRClusterOccupancySensingAttributePhysicalContactOccupiedToUnoccupiedDelayID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributePhysicalContactUnoccupiedToOccupiedDelayID)
                                             params:params];
}

- (void)writeAttributePhysicalContactUnoccupiedToOccupiedDelayWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributePhysicalContactUnoccupiedToOccupiedDelayWithValue:dataValueDictionary
                                                    expectedValueInterval:expectedValueIntervalMs
                                                                   params:nil];
}
- (void)writeAttributePhysicalContactUnoccupiedToOccupiedDelayWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOccupancySensingID)
                                  attributeId:@(MTRClusterOccupancySensingAttributePhysicalContactUnoccupiedToOccupiedDelayID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithParams:
    (MTRReadParams * _Nullable)params
{
    return [self.device
        readAttributeWithEndpointId:@(_endpoint)
                          clusterId:@(MTRClusterOccupancySensingID)
                        attributeId:@(MTRClusterOccupancySensingAttributePhysicalContactUnoccupiedToOccupiedThresholdID)
                             params:params];
}

- (void)writeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithValue:dataValueDictionary
                                                        expectedValueInterval:expectedValueIntervalMs
                                                                       params:nil];
}
- (void)writeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterOccupancySensingID)
                                  attributeId:@(MTRClusterOccupancySensingAttributePhysicalContactUnoccupiedToOccupiedThresholdID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterOccupancySensingID)
                                        attributeId:@(MTRClusterOccupancySensingAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterWakeOnLan

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeMACAddressWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWakeOnLanID)
                                        attributeId:@(MTRClusterWakeOnLanAttributeMACAddressID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWakeOnLanID)
                                        attributeId:@(MTRClusterWakeOnLanAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWakeOnLanID)
                                        attributeId:@(MTRClusterWakeOnLanAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWakeOnLanID)
                                        attributeId:@(MTRClusterWakeOnLanAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWakeOnLanID)
                                        attributeId:@(MTRClusterWakeOnLanAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterWakeOnLanID)
                                        attributeId:@(MTRClusterWakeOnLanAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterChannel

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)changeChannelWithParams:(MTRChannelClusterChangeChannelParams *)params
                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(void (^)(MTRChannelClusterChangeChannelResponseParams * _Nullable data,
                                    NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)changeChannelByNumberWithParams:(MTRChannelClusterChangeChannelByNumberParams *)params
                         expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                      completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)skipChannelWithParams:(MTRChannelClusterSkipChannelParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeChannelListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterChannelID)
                                        attributeId:@(MTRClusterChannelAttributeChannelListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLineupWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterChannelID)
                                        attributeId:@(MTRClusterChannelAttributeLineupID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentChannelWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterChannelID)
                                        attributeId:@(MTRClusterChannelAttributeCurrentChannelID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterChannelID)
                                        attributeId:@(MTRClusterChannelAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterChannelID)
                                        attributeId:@(MTRClusterChannelAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterChannelID)
                                        attributeId:@(MTRClusterChannelAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterChannelID)
                                        attributeId:@(MTRClusterChannelAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterChannelID)
                                        attributeId:@(MTRClusterChannelAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterTargetNavigator

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)navigateTargetWithParams:(MTRTargetNavigatorClusterNavigateTargetParams *)params
                  expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
               completionHandler:(void (^)(MTRTargetNavigatorClusterNavigateTargetResponseParams * _Nullable data,
                                     NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeTargetListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTargetNavigatorID)
                                        attributeId:@(MTRClusterTargetNavigatorAttributeTargetListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentTargetWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTargetNavigatorID)
                                        attributeId:@(MTRClusterTargetNavigatorAttributeCurrentTargetID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTargetNavigatorID)
                                        attributeId:@(MTRClusterTargetNavigatorAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTargetNavigatorID)
                                        attributeId:@(MTRClusterTargetNavigatorAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTargetNavigatorID)
                                        attributeId:@(MTRClusterTargetNavigatorAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTargetNavigatorID)
                                        attributeId:@(MTRClusterTargetNavigatorAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTargetNavigatorID)
                                        attributeId:@(MTRClusterTargetNavigatorAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterMediaPlayback

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)playWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                   NSError * _Nullable error))completionHandler
{
    [self playWithParams:nil
               expectedValues:expectedValues
        expectedValueInterval:expectedValueIntervalMs
            completionHandler:completionHandler];
}
- (void)playWithParams:(MTRMediaPlaybackClusterPlayParams * _Nullable)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:
            (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }

                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];
}

- (void)pauseWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                    NSError * _Nullable error))completionHandler
{
    [self pauseWithParams:nil
               expectedValues:expectedValues
        expectedValueInterval:expectedValueIntervalMs
            completionHandler:completionHandler];
}
- (void)pauseWithParams:(MTRMediaPlaybackClusterPauseParams * _Nullable)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:
            (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }

                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];
}

- (void)stopPlaybackWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                     completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                           NSError * _Nullable error))completionHandler
{
    [self stopPlaybackWithParams:nil
                  expectedValues:expectedValues
           expectedValueInterval:expectedValueIntervalMs
               completionHandler:completionHandler];
}
- (void)stopPlaybackWithParams:(MTRMediaPlaybackClusterStopPlaybackParams * _Nullable)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                   NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }

                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];
}

- (void)startOverWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                  completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                        NSError * _Nullable error))completionHandler
{
    [self startOverWithParams:nil
               expectedValues:expectedValues
        expectedValueInterval:expectedValueIntervalMs
            completionHandler:completionHandler];
}
- (void)startOverWithParams:(MTRMediaPlaybackClusterStartOverParams * _Nullable)params
             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
          completionHandler:
              (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }

                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];
}

- (void)previousWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                 completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                       NSError * _Nullable error))completionHandler
{
    [self previousWithParams:nil
               expectedValues:expectedValues
        expectedValueInterval:expectedValueIntervalMs
            completionHandler:completionHandler];
}
- (void)previousWithParams:(MTRMediaPlaybackClusterPreviousParams * _Nullable)params
            expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
         completionHandler:
             (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }

                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];
}

- (void)nextWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                   NSError * _Nullable error))completionHandler
{
    [self nextWithParams:nil
               expectedValues:expectedValues
        expectedValueInterval:expectedValueIntervalMs
            completionHandler:completionHandler];
}
- (void)nextWithParams:(MTRMediaPlaybackClusterNextParams * _Nullable)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:
            (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }

                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];
}

- (void)rewindWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
               completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                     NSError * _Nullable error))completionHandler
{
    [self rewindWithParams:nil
               expectedValues:expectedValues
        expectedValueInterval:expectedValueIntervalMs
            completionHandler:completionHandler];
}
- (void)rewindWithParams:(MTRMediaPlaybackClusterRewindParams * _Nullable)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:
            (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }

                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];
}

- (void)fastForwardWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                    completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                          NSError * _Nullable error))completionHandler
{
    [self fastForwardWithParams:nil
                 expectedValues:expectedValues
          expectedValueInterval:expectedValueIntervalMs
              completionHandler:completionHandler];
}
- (void)fastForwardWithParams:(MTRMediaPlaybackClusterFastForwardParams * _Nullable)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                  NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }

                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];
}

- (void)skipForwardWithParams:(MTRMediaPlaybackClusterSkipForwardParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                  NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)skipBackwardWithParams:(MTRMediaPlaybackClusterSkipBackwardParams *)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                   NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)seekWithParams:(MTRMediaPlaybackClusterSeekParams *)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:
            (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentStateWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaPlaybackID)
                                        attributeId:@(MTRClusterMediaPlaybackAttributeCurrentStateID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeStartTimeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaPlaybackID)
                                        attributeId:@(MTRClusterMediaPlaybackAttributeStartTimeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDurationWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaPlaybackID)
                                        attributeId:@(MTRClusterMediaPlaybackAttributeDurationID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSampledPositionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaPlaybackID)
                                        attributeId:@(MTRClusterMediaPlaybackAttributeSampledPositionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePlaybackSpeedWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaPlaybackID)
                                        attributeId:@(MTRClusterMediaPlaybackAttributePlaybackSpeedID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSeekRangeEndWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaPlaybackID)
                                        attributeId:@(MTRClusterMediaPlaybackAttributeSeekRangeEndID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSeekRangeStartWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaPlaybackID)
                                        attributeId:@(MTRClusterMediaPlaybackAttributeSeekRangeStartID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaPlaybackID)
                                        attributeId:@(MTRClusterMediaPlaybackAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaPlaybackID)
                                        attributeId:@(MTRClusterMediaPlaybackAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaPlaybackID)
                                        attributeId:@(MTRClusterMediaPlaybackAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaPlaybackID)
                                        attributeId:@(MTRClusterMediaPlaybackAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaPlaybackID)
                                        attributeId:@(MTRClusterMediaPlaybackAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterMediaInput

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)selectInputWithParams:(MTRMediaInputClusterSelectInputParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)showInputStatusWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                        completionHandler:(StatusCompletion)completionHandler
{
    [self showInputStatusWithParams:nil
                     expectedValues:expectedValues
              expectedValueInterval:expectedValueIntervalMs
                  completionHandler:completionHandler];
}
- (void)showInputStatusWithParams:(MTRMediaInputClusterShowInputStatusParams * _Nullable)params
                   expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)hideInputStatusWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                        completionHandler:(StatusCompletion)completionHandler
{
    [self hideInputStatusWithParams:nil
                     expectedValues:expectedValues
              expectedValueInterval:expectedValueIntervalMs
                  completionHandler:completionHandler];
}
- (void)hideInputStatusWithParams:(MTRMediaInputClusterHideInputStatusParams * _Nullable)params
                   expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)renameInputWithParams:(MTRMediaInputClusterRenameInputParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeInputListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaInputID)
                                        attributeId:@(MTRClusterMediaInputAttributeInputListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentInputWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaInputID)
                                        attributeId:@(MTRClusterMediaInputAttributeCurrentInputID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaInputID)
                                        attributeId:@(MTRClusterMediaInputAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaInputID)
                                        attributeId:@(MTRClusterMediaInputAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaInputID)
                                        attributeId:@(MTRClusterMediaInputAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaInputID)
                                        attributeId:@(MTRClusterMediaInputAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterMediaInputID)
                                        attributeId:@(MTRClusterMediaInputAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterLowPower

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)sleepWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(StatusCompletion)completionHandler
{
    [self sleepWithParams:nil
               expectedValues:expectedValues
        expectedValueInterval:expectedValueIntervalMs
            completionHandler:completionHandler];
}
- (void)sleepWithParams:(MTRLowPowerClusterSleepParams * _Nullable)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLowPowerID)
                                        attributeId:@(MTRClusterLowPowerAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLowPowerID)
                                        attributeId:@(MTRClusterLowPowerAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLowPowerID)
                                        attributeId:@(MTRClusterLowPowerAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLowPowerID)
                                        attributeId:@(MTRClusterLowPowerAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterLowPowerID)
                                        attributeId:@(MTRClusterLowPowerAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterKeypadInput

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)sendKeyWithParams:(MTRKeypadInputClusterSendKeyParams *)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:
            (void (^)(MTRKeypadInputClusterSendKeyResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterKeypadInputID)
                                        attributeId:@(MTRClusterKeypadInputAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterKeypadInputID)
                                        attributeId:@(MTRClusterKeypadInputAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterKeypadInputID)
                                        attributeId:@(MTRClusterKeypadInputAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterKeypadInputID)
                                        attributeId:@(MTRClusterKeypadInputAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterKeypadInputID)
                                        attributeId:@(MTRClusterKeypadInputAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterContentLauncher

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)launchContentWithParams:(MTRContentLauncherClusterLaunchContentParams *)params
                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
              completionHandler:(void (^)(MTRContentLauncherClusterLaunchResponseParams * _Nullable data,
                                    NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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.
                                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.
                                                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();
                                    }
                                }
                            }
                        }
                        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);
            });
    }];

    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
}

- (void)launchURLWithParams:(MTRContentLauncherClusterLaunchURLParams *)params
             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
          completionHandler:
              (void (^)(MTRContentLauncherClusterLaunchResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                        }
                    }
                    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.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 != 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];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptHeaderWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterContentLauncherID)
                                        attributeId:@(MTRClusterContentLauncherAttributeAcceptHeaderID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeSupportedStreamingProtocolsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterContentLauncherID)
                                        attributeId:@(MTRClusterContentLauncherAttributeSupportedStreamingProtocolsID)
                                             params:params];
}

- (void)writeAttributeSupportedStreamingProtocolsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeSupportedStreamingProtocolsWithValue:dataValueDictionary
                                       expectedValueInterval:expectedValueIntervalMs
                                                      params:nil];
}
- (void)writeAttributeSupportedStreamingProtocolsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterContentLauncherID)
                                  attributeId:@(MTRClusterContentLauncherAttributeSupportedStreamingProtocolsID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterContentLauncherID)
                                        attributeId:@(MTRClusterContentLauncherAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterContentLauncherID)
                                        attributeId:@(MTRClusterContentLauncherAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterContentLauncherID)
                                        attributeId:@(MTRClusterContentLauncherAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterContentLauncherID)
                                        attributeId:@(MTRClusterContentLauncherAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterContentLauncherID)
                                        attributeId:@(MTRClusterContentLauncherAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterAudioOutput

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)selectOutputWithParams:(MTRAudioOutputClusterSelectOutputParams *)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)renameOutputWithParams:(MTRAudioOutputClusterRenameOutputParams *)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeOutputListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAudioOutputID)
                                        attributeId:@(MTRClusterAudioOutputAttributeOutputListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentOutputWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAudioOutputID)
                                        attributeId:@(MTRClusterAudioOutputAttributeCurrentOutputID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAudioOutputID)
                                        attributeId:@(MTRClusterAudioOutputAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAudioOutputID)
                                        attributeId:@(MTRClusterAudioOutputAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAudioOutputID)
                                        attributeId:@(MTRClusterAudioOutputAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAudioOutputID)
                                        attributeId:@(MTRClusterAudioOutputAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAudioOutputID)
                                        attributeId:@(MTRClusterAudioOutputAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterApplicationLauncher

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)launchAppWithParams:(MTRApplicationLauncherClusterLaunchAppParams *)params
             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
          completionHandler:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data,
                                NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)stopAppWithParams:(MTRApplicationLauncherClusterStopAppParams *)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data,
                              NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)hideAppWithParams:(MTRApplicationLauncherClusterHideAppParams *)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data,
                              NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (NSDictionary<NSString *, id> *)readAttributeCatalogListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationLauncherID)
                                        attributeId:@(MTRClusterApplicationLauncherAttributeCatalogListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentAppWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationLauncherID)
                                        attributeId:@(MTRClusterApplicationLauncherAttributeCurrentAppID)
                                             params:params];
}

- (void)writeAttributeCurrentAppWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeCurrentAppWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeCurrentAppWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                   params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterApplicationLauncherID)
                                  attributeId:@(MTRClusterApplicationLauncherAttributeCurrentAppID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationLauncherID)
                                        attributeId:@(MTRClusterApplicationLauncherAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationLauncherID)
                                        attributeId:@(MTRClusterApplicationLauncherAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationLauncherID)
                                        attributeId:@(MTRClusterApplicationLauncherAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationLauncherID)
                                        attributeId:@(MTRClusterApplicationLauncherAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationLauncherID)
                                        attributeId:@(MTRClusterApplicationLauncherAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterApplicationBasic

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (NSDictionary<NSString *, id> *)readAttributeVendorNameWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationBasicID)
                                        attributeId:@(MTRClusterApplicationBasicAttributeVendorNameID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeVendorIDWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationBasicID)
                                        attributeId:@(MTRClusterApplicationBasicAttributeVendorIDID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeApplicationNameWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationBasicID)
                                        attributeId:@(MTRClusterApplicationBasicAttributeApplicationNameID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeProductIDWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationBasicID)
                                        attributeId:@(MTRClusterApplicationBasicAttributeProductIDID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeApplicationWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationBasicID)
                                        attributeId:@(MTRClusterApplicationBasicAttributeApplicationID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeStatusWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationBasicID)
                                        attributeId:@(MTRClusterApplicationBasicAttributeStatusID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeApplicationVersionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationBasicID)
                                        attributeId:@(MTRClusterApplicationBasicAttributeApplicationVersionID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAllowedVendorListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationBasicID)
                                        attributeId:@(MTRClusterApplicationBasicAttributeAllowedVendorListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationBasicID)
                                        attributeId:@(MTRClusterApplicationBasicAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationBasicID)
                                        attributeId:@(MTRClusterApplicationBasicAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationBasicID)
                                        attributeId:@(MTRClusterApplicationBasicAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationBasicID)
                                        attributeId:@(MTRClusterApplicationBasicAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterApplicationBasicID)
                                        attributeId:@(MTRClusterApplicationBasicAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterAccountLogin

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)getSetupPINWithParams:(MTRAccountLoginClusterGetSetupPINParams *)params
               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
            completionHandler:(void (^)(MTRAccountLoginClusterGetSetupPINResponseParams * _Nullable data,
                                  NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)loginWithParams:(MTRAccountLoginClusterLoginParams *)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)logoutWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
               completionHandler:(StatusCompletion)completionHandler
{
    [self logoutWithParams:nil
               expectedValues:expectedValues
        expectedValueInterval:expectedValueIntervalMs
            completionHandler:completionHandler];
}
- (void)logoutWithParams:(MTRAccountLoginClusterLogoutParams * _Nullable)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccountLoginID)
                                        attributeId:@(MTRClusterAccountLoginAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccountLoginID)
                                        attributeId:@(MTRClusterAccountLoginAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccountLoginID)
                                        attributeId:@(MTRClusterAccountLoginAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccountLoginID)
                                        attributeId:@(MTRClusterAccountLoginAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterAccountLoginID)
                                        attributeId:@(MTRClusterAccountLoginAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterElectricalMeasurement

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)getProfileInfoCommandWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                              completionHandler:(StatusCompletion)completionHandler
{
    [self getProfileInfoCommandWithParams:nil
                           expectedValues:expectedValues
                    expectedValueInterval:expectedValueIntervalMs
                        completionHandler:completionHandler];
}
- (void)getProfileInfoCommandWithParams:(MTRElectricalMeasurementClusterGetProfileInfoCommandParams * _Nullable)params
                         expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                      completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)getMeasurementProfileCommandWithParams:(MTRElectricalMeasurementClusterGetMeasurementProfileCommandParams *)params
                                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                             completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeMeasurementTypeWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeMeasurementTypeID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcVoltageWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcVoltageID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcVoltageMinWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcVoltageMinID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcVoltageMaxWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcVoltageMaxID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcCurrentMinWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcCurrentMinID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcCurrentMaxWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcCurrentMaxID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcPowerWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcPowerID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcPowerMinWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcPowerMinID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcPowerMaxWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcPowerMaxID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcVoltageMultiplierWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcVoltageMultiplierID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcVoltageDivisorWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcVoltageDivisorID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcCurrentMultiplierWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcCurrentMultiplierID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcCurrentDivisorWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcCurrentDivisorID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcPowerMultiplierWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcPowerMultiplierID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeDcPowerDivisorWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeDcPowerDivisorID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcFrequencyWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcFrequencyID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcFrequencyMinWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcFrequencyMinID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcFrequencyMaxWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcFrequencyMaxID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeNeutralCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeNeutralCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTotalActivePowerWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeTotalActivePowerID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTotalReactivePowerWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeTotalReactivePowerID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeTotalApparentPowerWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeTotalApparentPowerID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMeasured1stHarmonicCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeMeasured1stHarmonicCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMeasured3rdHarmonicCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeMeasured3rdHarmonicCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMeasured5thHarmonicCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeMeasured5thHarmonicCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMeasured7thHarmonicCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeMeasured7thHarmonicCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMeasured9thHarmonicCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeMeasured9thHarmonicCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMeasured11thHarmonicCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeMeasured11thHarmonicCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMeasuredPhase1stHarmonicCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeMeasuredPhase1stHarmonicCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMeasuredPhase3rdHarmonicCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeMeasuredPhase3rdHarmonicCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMeasuredPhase5thHarmonicCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeMeasuredPhase5thHarmonicCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMeasuredPhase7thHarmonicCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeMeasuredPhase7thHarmonicCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMeasuredPhase9thHarmonicCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeMeasuredPhase9thHarmonicCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeMeasuredPhase11thHarmonicCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeMeasuredPhase11thHarmonicCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcFrequencyMultiplierWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcFrequencyMultiplierID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcFrequencyDivisorWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcFrequencyDivisorID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePowerMultiplierWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributePowerMultiplierID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePowerDivisorWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributePowerDivisorID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeHarmonicCurrentMultiplierWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeHarmonicCurrentMultiplierID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePhaseHarmonicCurrentMultiplierWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributePhaseHarmonicCurrentMultiplierID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeInstantaneousVoltageWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeInstantaneousVoltageID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeInstantaneousLineCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeInstantaneousLineCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeInstantaneousActiveCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeInstantaneousActiveCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeInstantaneousReactiveCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeInstantaneousReactiveCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeInstantaneousPowerWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeInstantaneousPowerID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageMinWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageMinID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageMaxWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageMaxID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsCurrentWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsCurrentID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsCurrentMinWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsCurrentMinID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsCurrentMaxWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsCurrentMaxID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActivePowerWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeActivePowerID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActivePowerMinWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeActivePowerMinID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActivePowerMaxWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeActivePowerMaxID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeReactivePowerWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeReactivePowerID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeApparentPowerWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeApparentPowerID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePowerFactorWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributePowerFactorID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAverageRmsVoltageMeasurementPeriodWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAverageRmsVoltageMeasurementPeriodID)
                                             params:params];
}

- (void)writeAttributeAverageRmsVoltageMeasurementPeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeAverageRmsVoltageMeasurementPeriodWithValue:dataValueDictionary
                                              expectedValueInterval:expectedValueIntervalMs
                                                             params:nil];
}
- (void)writeAttributeAverageRmsVoltageMeasurementPeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                           params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterElectricalMeasurementID)
                                  attributeId:@(MTRClusterElectricalMeasurementAttributeAverageRmsVoltageMeasurementPeriodID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeAverageRmsUnderVoltageCounterWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAverageRmsUnderVoltageCounterID)
                                             params:params];
}

- (void)writeAttributeAverageRmsUnderVoltageCounterWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeAverageRmsUnderVoltageCounterWithValue:dataValueDictionary
                                         expectedValueInterval:expectedValueIntervalMs
                                                        params:nil];
}
- (void)writeAttributeAverageRmsUnderVoltageCounterWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterElectricalMeasurementID)
                                  attributeId:@(MTRClusterElectricalMeasurementAttributeAverageRmsUnderVoltageCounterID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsExtremeOverVoltagePeriodWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsExtremeOverVoltagePeriodID)
                                             params:params];
}

- (void)writeAttributeRmsExtremeOverVoltagePeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeRmsExtremeOverVoltagePeriodWithValue:dataValueDictionary
                                       expectedValueInterval:expectedValueIntervalMs
                                                      params:nil];
}
- (void)writeAttributeRmsExtremeOverVoltagePeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterElectricalMeasurementID)
                                  attributeId:@(MTRClusterElectricalMeasurementAttributeRmsExtremeOverVoltagePeriodID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsExtremeUnderVoltagePeriodWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsExtremeUnderVoltagePeriodID)
                                             params:params];
}

- (void)writeAttributeRmsExtremeUnderVoltagePeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeRmsExtremeUnderVoltagePeriodWithValue:dataValueDictionary
                                        expectedValueInterval:expectedValueIntervalMs
                                                       params:nil];
}
- (void)writeAttributeRmsExtremeUnderVoltagePeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterElectricalMeasurementID)
                                  attributeId:@(MTRClusterElectricalMeasurementAttributeRmsExtremeUnderVoltagePeriodID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageSagPeriodWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageSagPeriodID)
                                             params:params];
}

- (void)writeAttributeRmsVoltageSagPeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeRmsVoltageSagPeriodWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeRmsVoltageSagPeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterElectricalMeasurementID)
                                  attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageSagPeriodID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageSwellPeriodWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageSwellPeriodID)
                                             params:params];
}

- (void)writeAttributeRmsVoltageSwellPeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeRmsVoltageSwellPeriodWithValue:dataValueDictionary
                                 expectedValueInterval:expectedValueIntervalMs
                                                params:nil];
}
- (void)writeAttributeRmsVoltageSwellPeriodWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                              params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterElectricalMeasurementID)
                                  attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageSwellPeriodID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeAcVoltageMultiplierWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcVoltageMultiplierID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcVoltageDivisorWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcVoltageDivisorID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcCurrentMultiplierWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcCurrentMultiplierID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcCurrentDivisorWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcCurrentDivisorID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcPowerMultiplierWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcPowerMultiplierID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcPowerDivisorWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcPowerDivisorID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeOverloadAlarmsMaskWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeOverloadAlarmsMaskID)
                                             params:params];
}

- (void)writeAttributeOverloadAlarmsMaskWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOverloadAlarmsMaskWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOverloadAlarmsMaskWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                           params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterElectricalMeasurementID)
                                  attributeId:@(MTRClusterElectricalMeasurementAttributeOverloadAlarmsMaskID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeVoltageOverloadWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeVoltageOverloadID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeCurrentOverloadWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeCurrentOverloadID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcOverloadAlarmsMaskWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcOverloadAlarmsMaskID)
                                             params:params];
}

- (void)writeAttributeAcOverloadAlarmsMaskWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeAcOverloadAlarmsMaskWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeAcOverloadAlarmsMaskWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                             params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterElectricalMeasurementID)
                                  attributeId:@(MTRClusterElectricalMeasurementAttributeAcOverloadAlarmsMaskID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeAcVoltageOverloadWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcVoltageOverloadID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcCurrentOverloadWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcCurrentOverloadID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcActivePowerOverloadWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcActivePowerOverloadID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcReactivePowerOverloadWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcReactivePowerOverloadID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAverageRmsOverVoltageWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAverageRmsOverVoltageID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAverageRmsUnderVoltageWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAverageRmsUnderVoltageID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsExtremeOverVoltageWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsExtremeOverVoltageID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsExtremeUnderVoltageWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsExtremeUnderVoltageID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageSagWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageSagID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageSwellWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageSwellID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLineCurrentPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeLineCurrentPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActiveCurrentPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeActiveCurrentPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeReactiveCurrentPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeReactiveCurrentPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltagePhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltagePhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageMinPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageMinPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageMaxPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageMaxPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsCurrentPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsCurrentPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsCurrentMinPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsCurrentMinPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsCurrentMaxPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsCurrentMaxPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActivePowerPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeActivePowerPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActivePowerMinPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeActivePowerMinPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActivePowerMaxPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeActivePowerMaxPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeReactivePowerPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeReactivePowerPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeApparentPowerPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeApparentPowerPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePowerFactorPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributePowerFactorPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device
        readAttributeWithEndpointId:@(_endpoint)
                          clusterId:@(MTRClusterElectricalMeasurementID)
                        attributeId:@(MTRClusterElectricalMeasurementAttributeAverageRmsVoltageMeasurementPeriodPhaseBID)
                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAverageRmsOverVoltageCounterPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAverageRmsOverVoltageCounterPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAverageRmsUnderVoltageCounterPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAverageRmsUnderVoltageCounterPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsExtremeOverVoltagePeriodPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsExtremeUnderVoltagePeriodPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageSagPeriodPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageSagPeriodPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageSwellPeriodPhaseBWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageSwellPeriodPhaseBID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeLineCurrentPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeLineCurrentPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActiveCurrentPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeActiveCurrentPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeReactiveCurrentPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeReactiveCurrentPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltagePhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltagePhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageMinPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageMinPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageMaxPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageMaxPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsCurrentPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsCurrentPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsCurrentMinPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsCurrentMinPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsCurrentMaxPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsCurrentMaxPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActivePowerPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeActivePowerPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActivePowerMinPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeActivePowerMinPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeActivePowerMaxPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeActivePowerMaxPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeReactivePowerPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeReactivePowerPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeApparentPowerPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeApparentPowerPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributePowerFactorPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributePowerFactorPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device
        readAttributeWithEndpointId:@(_endpoint)
                          clusterId:@(MTRClusterElectricalMeasurementID)
                        attributeId:@(MTRClusterElectricalMeasurementAttributeAverageRmsVoltageMeasurementPeriodPhaseCID)
                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAverageRmsOverVoltageCounterPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAverageRmsOverVoltageCounterPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAverageRmsUnderVoltageCounterPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAverageRmsUnderVoltageCounterPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsExtremeOverVoltagePeriodPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsExtremeUnderVoltagePeriodPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageSagPeriodPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageSagPeriodPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeRmsVoltageSwellPeriodPhaseCWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeRmsVoltageSwellPeriodPhaseCID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterElectricalMeasurementID)
                                        attributeId:@(MTRClusterElectricalMeasurementAttributeClusterRevisionID)
                                             params:params];
}

@end

@implementation MTRClusterTestCluster

- (instancetype)initWithDevice:(MTRDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

        _endpoint = endpoint;
        _device = device;
    }
    return self;
}

- (void)testWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(StatusCompletion)completionHandler
{
    [self testWithParams:nil
               expectedValues:expectedValues
        expectedValueInterval:expectedValueIntervalMs
            completionHandler:completionHandler];
}
- (void)testWithParams:(MTRTestClusterClusterTestParams * _Nullable)params
           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
        completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)testNotHandledWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                       completionHandler:(StatusCompletion)completionHandler
{
    [self testNotHandledWithParams:nil
                    expectedValues:expectedValues
             expectedValueInterval:expectedValueIntervalMs
                 completionHandler:completionHandler];
}
- (void)testNotHandledWithParams:(MTRTestClusterClusterTestNotHandledParams * _Nullable)params
                  expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
               completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)testSpecificWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                     completionHandler:(void (^)(MTRTestClusterClusterTestSpecificResponseParams * _Nullable data,
                                           NSError * _Nullable error))completionHandler
{
    [self testSpecificWithParams:nil
                  expectedValues:expectedValues
           expectedValueInterval:expectedValueIntervalMs
               completionHandler:completionHandler];
}
- (void)testSpecificWithParams:(MTRTestClusterClusterTestSpecificParams * _Nullable)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
             completionHandler:(void (^)(MTRTestClusterClusterTestSpecificResponseParams * _Nullable data,
                                   NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }

                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];
}

- (void)testUnknownCommandWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                           completionHandler:(StatusCompletion)completionHandler
{
    [self testUnknownCommandWithParams:nil
                        expectedValues:expectedValues
                 expectedValueInterval:expectedValueIntervalMs
                     completionHandler:completionHandler];
}
- (void)testUnknownCommandWithParams:(MTRTestClusterClusterTestUnknownCommandParams * _Nullable)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)testAddArgumentsWithParams:(MTRTestClusterClusterTestAddArgumentsParams *)params
                    expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                 completionHandler:(void (^)(MTRTestClusterClusterTestAddArgumentsResponseParams * _Nullable data,
                                       NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)testSimpleArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleArgumentRequestParams *)params
                             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                          completionHandler:(void (^)(MTRTestClusterClusterTestSimpleArgumentResponseParams * _Nullable data,
                                                NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)testStructArrayArgumentRequestWithParams:(MTRTestClusterClusterTestStructArrayArgumentRequestParams *)params
                                  expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               completionHandler:
                                   (void (^)(MTRTestClusterClusterTestStructArrayArgumentResponseParams * _Nullable data,
                                       NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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.
                                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.
                                            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();
                                }
                            }
                            {
                                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.
                                            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();
                                }
                            }
                            {
                                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.
                                            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();
                                }
                            }
                            {
                                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.
                                            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();
                                }
                            }
                        }
                        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.
                                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.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();
                    }
                }
                {
                    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.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.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];
}

- (void)testStructArgumentRequestWithParams:(MTRTestClusterClusterTestStructArgumentRequestParams *)params
                             expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                          completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)testNestedStructArgumentRequestWithParams:(MTRTestClusterClusterTestNestedStructArgumentRequestParams *)params
                                   expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                      NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)testListStructArgumentRequestWithParams:(MTRTestClusterClusterTestListStructArgumentRequestParams *)params
                                 expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                              completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                    NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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.
                                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();
                    }
                }

                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];
}

- (void)testListInt8UArgumentRequestWithParams:(MTRTestClusterClusterTestListInt8UArgumentRequestParams *)params
                                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                             completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                   NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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.
                                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();
                    }
                }

                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];
}

- (void)testNestedStructListArgumentRequestWithParams:(MTRTestClusterClusterTestNestedStructListArgumentRequestParams *)params
                                       expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                          NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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.
                                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.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();
                    }
                }
                {
                    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.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();
                    }
                }
                {
                    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.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();
                    }
                }

                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];
}

- (void)testListNestedStructListArgumentRequestWithParams:
            (MTRTestClusterClusterTestListNestedStructListArgumentRequestParams *)params
                                           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                        completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                              NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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.
                                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.
                                            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();
                                }
                            }
                            {
                                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.
                                            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();
                                }
                            }
                            {
                                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.
                                            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();
                                }
                            }
                            {
                                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.
                                            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();
                                }
                            }
                        }
                        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];
}

- (void)testListInt8UReverseRequestWithParams:(MTRTestClusterClusterTestListInt8UReverseRequestParams *)params
                               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                            completionHandler:(void (^)(MTRTestClusterClusterTestListInt8UReverseResponseParams * _Nullable data,
                                                  NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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.
                                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();
                    }
                }

                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];
}

- (void)testEnumsRequestWithParams:(MTRTestClusterClusterTestEnumsRequestParams *)params
                    expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                 completionHandler:(void (^)(MTRTestClusterClusterTestEnumsResponseParams * _Nullable data,
                                       NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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);
                    }
                }
                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];
}

- (void)testNullableOptionalRequestWithParams:(MTRTestClusterClusterTestNullableOptionalRequestParams * _Nullable)params
                               expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                            completionHandler:(void (^)(MTRTestClusterClusterTestNullableOptionalResponseParams * _Nullable data,
                                                  NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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;
                        }
                    }
                }

                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];
}

- (void)testComplexNullableOptionalRequestWithParams:(MTRTestClusterClusterTestComplexNullableOptionalRequestParams *)params
                                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                   completionHandler:
                                       (void (^)(MTRTestClusterClusterTestComplexNullableOptionalResponseParams * _Nullable data,
                                           NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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();
                    } 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();
                    } 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();
                    } 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);
                        } else {
                            nonNullValue_0 = ListType_1();
                        }
                    }
                }
                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.
                                    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);
                            }
                            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();
                        {
                            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];
}

- (void)simpleStructEchoRequestWithParams:(MTRTestClusterClusterSimpleStructEchoRequestParams *)params
                           expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                        completionHandler:(void (^)(MTRTestClusterClusterSimpleStructResponseParams * _Nullable data,
                                              NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)timedInvokeRequestWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                           completionHandler:(StatusCompletion)completionHandler
{
    [self timedInvokeRequestWithParams:nil
                        expectedValues:expectedValues
                 expectedValueInterval:expectedValueIntervalMs
                     completionHandler:completionHandler];
}
- (void)timedInvokeRequestWithParams:(MTRTestClusterClusterTimedInvokeRequestParams * _Nullable)params
                      expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                   completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)testSimpleOptionalArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleOptionalArgumentRequestParams * _Nullable)params
                                     expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                  completionHandler:(StatusCompletion)completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)testEmitTestEventRequestWithParams:(MTRTestClusterClusterTestEmitTestEventRequestParams *)params
                            expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                         completionHandler:(void (^)(MTRTestClusterClusterTestEmitTestEventResponseParams * _Nullable data,
                                               NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (void)testEmitTestFabricScopedEventRequestWithParams:(MTRTestClusterClusterTestEmitTestFabricScopedEventRequestParams *)params
                                        expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
                                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                     completionHandler:
                                         (void (^)(
                                             MTRTestClusterClusterTestEmitTestFabricScopedEventResponseParams * _Nullable data,
                                             NSError * _Nullable error))completionHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    [self.device connectAndPerformAsync:^(MTRBaseDevice * baseDevice) {
        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];
}

- (NSDictionary<NSString *, id> *)readAttributeBooleanWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeBooleanID)
                                             params:params];
}

- (void)writeAttributeBooleanWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBooleanWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeBooleanWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeBooleanID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeBitmap8WithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeBitmap8ID)
                                             params:params];
}

- (void)writeAttributeBitmap8WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBitmap8WithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeBitmap8WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeBitmap8ID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeBitmap16WithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeBitmap16ID)
                                             params:params];
}

- (void)writeAttributeBitmap16WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBitmap16WithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeBitmap16WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeBitmap16ID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeBitmap32WithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeBitmap32ID)
                                             params:params];
}

- (void)writeAttributeBitmap32WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBitmap32WithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeBitmap32WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeBitmap32ID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeBitmap64WithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeBitmap64ID)
                                             params:params];
}

- (void)writeAttributeBitmap64WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeBitmap64WithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeBitmap64WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeBitmap64ID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt8uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt8uID)
                                             params:params];
}

- (void)writeAttributeInt8uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt8uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt8uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                              params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt8uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt16uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt16uID)
                                             params:params];
}

- (void)writeAttributeInt16uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt16uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt16uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt16uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt24uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt24uID)
                                             params:params];
}

- (void)writeAttributeInt24uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt24uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt24uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt24uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt32uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt32uID)
                                             params:params];
}

- (void)writeAttributeInt32uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt32uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt32uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt32uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt40uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt40uID)
                                             params:params];
}

- (void)writeAttributeInt40uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt40uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt40uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt40uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt48uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt48uID)
                                             params:params];
}

- (void)writeAttributeInt48uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt48uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt48uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt48uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt56uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt56uID)
                                             params:params];
}

- (void)writeAttributeInt56uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt56uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt56uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt56uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt64uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt64uID)
                                             params:params];
}

- (void)writeAttributeInt64uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt64uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt64uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt64uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt8sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt8sID)
                                             params:params];
}

- (void)writeAttributeInt8sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt8sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt8sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                              params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt8sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt16sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt16sID)
                                             params:params];
}

- (void)writeAttributeInt16sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt16sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt16sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt16sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt24sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt24sID)
                                             params:params];
}

- (void)writeAttributeInt24sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt24sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt24sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt24sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt32sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt32sID)
                                             params:params];
}

- (void)writeAttributeInt32sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt32sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt32sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt32sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt40sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt40sID)
                                             params:params];
}

- (void)writeAttributeInt40sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt40sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt40sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt40sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt48sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt48sID)
                                             params:params];
}

- (void)writeAttributeInt48sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt48sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt48sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt48sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt56sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt56sID)
                                             params:params];
}

- (void)writeAttributeInt56sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt56sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt56sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt56sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeInt64sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeInt64sID)
                                             params:params];
}

- (void)writeAttributeInt64sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeInt64sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeInt64sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeInt64sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeEnum8WithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeEnum8ID)
                                             params:params];
}

- (void)writeAttributeEnum8WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeEnum8WithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeEnum8WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                              params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeEnum8ID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeEnum16WithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeEnum16ID)
                                             params:params];
}

- (void)writeAttributeEnum16WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeEnum16WithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeEnum16WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeEnum16ID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeFloatSingleWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeFloatSingleID)
                                             params:params];
}

- (void)writeAttributeFloatSingleWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeFloatSingleWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeFloatSingleWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeFloatSingleID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeFloatDoubleWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeFloatDoubleID)
                                             params:params];
}

- (void)writeAttributeFloatDoubleWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeFloatDoubleWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeFloatDoubleWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeFloatDoubleID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeOctetStringWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeOctetStringID)
                                             params:params];
}

- (void)writeAttributeOctetStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeOctetStringWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeOctetStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeOctetStringID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeListInt8uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeListInt8uID)
                                             params:params];
}

- (void)writeAttributeListInt8uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeListInt8uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeListInt8uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                   expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                  params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeListInt8uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeListOctetStringWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeListOctetStringID)
                                             params:params];
}

- (void)writeAttributeListOctetStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeListOctetStringWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeListOctetStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                        params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeListOctetStringID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeListStructOctetStringWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeListStructOctetStringID)
                                             params:params];
}

- (void)writeAttributeListStructOctetStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeListStructOctetStringWithValue:dataValueDictionary
                                 expectedValueInterval:expectedValueIntervalMs
                                                params:nil];
}
- (void)writeAttributeListStructOctetStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                              params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeListStructOctetStringID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeLongOctetStringWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeLongOctetStringID)
                                             params:params];
}

- (void)writeAttributeLongOctetStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLongOctetStringWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeLongOctetStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                        params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeLongOctetStringID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeCharStringWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeCharStringID)
                                             params:params];
}

- (void)writeAttributeCharStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeCharStringWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeCharStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                   params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeCharStringID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeLongCharStringWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeLongCharStringID)
                                             params:params];
}

- (void)writeAttributeLongCharStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeLongCharStringWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeLongCharStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeLongCharStringID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeEpochUsWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeEpochUsID)
                                             params:params];
}

- (void)writeAttributeEpochUsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeEpochUsWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeEpochUsWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                 expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeEpochUsID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeEpochSWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeEpochSID)
                                             params:params];
}

- (void)writeAttributeEpochSWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeEpochSWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeEpochSWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                               params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeEpochSID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeVendorIdWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeVendorIdID)
                                             params:params];
}

- (void)writeAttributeVendorIdWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeVendorIdWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeVendorIdWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeVendorIdID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeListNullablesAndOptionalsStructWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeListNullablesAndOptionalsStructID)
                                             params:params];
}

- (void)writeAttributeListNullablesAndOptionalsStructWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeListNullablesAndOptionalsStructWithValue:dataValueDictionary
                                           expectedValueInterval:expectedValueIntervalMs
                                                          params:nil];
}
- (void)writeAttributeListNullablesAndOptionalsStructWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                        params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeListNullablesAndOptionalsStructID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeEnumAttrWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeEnumAttrID)
                                             params:params];
}

- (void)writeAttributeEnumAttrWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeEnumAttrWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeEnumAttrWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                  expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                 params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeEnumAttrID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeStructAttrWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeStructAttrID)
                                             params:params];
}

- (void)writeAttributeStructAttrWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeStructAttrWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeStructAttrWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                    expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                   params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeStructAttrID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeRangeRestrictedInt8uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeRangeRestrictedInt8uID)
                                             params:params];
}

- (void)writeAttributeRangeRestrictedInt8uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeRangeRestrictedInt8uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeRangeRestrictedInt8uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                             params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeRangeRestrictedInt8uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeRangeRestrictedInt8sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeRangeRestrictedInt8sID)
                                             params:params];
}

- (void)writeAttributeRangeRestrictedInt8sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeRangeRestrictedInt8sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeRangeRestrictedInt8sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                              expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                             params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeRangeRestrictedInt8sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeRangeRestrictedInt16uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeRangeRestrictedInt16uID)
                                             params:params];
}

- (void)writeAttributeRangeRestrictedInt16uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeRangeRestrictedInt16uWithValue:dataValueDictionary
                                 expectedValueInterval:expectedValueIntervalMs
                                                params:nil];
}
- (void)writeAttributeRangeRestrictedInt16uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                              params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeRangeRestrictedInt16uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeRangeRestrictedInt16sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeRangeRestrictedInt16sID)
                                             params:params];
}

- (void)writeAttributeRangeRestrictedInt16sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeRangeRestrictedInt16sWithValue:dataValueDictionary
                                 expectedValueInterval:expectedValueIntervalMs
                                                params:nil];
}
- (void)writeAttributeRangeRestrictedInt16sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                               expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                              params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeRangeRestrictedInt16sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeListLongOctetStringWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeListLongOctetStringID)
                                             params:params];
}

- (void)writeAttributeListLongOctetStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeListLongOctetStringWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeListLongOctetStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeListLongOctetStringID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeListFabricScopedWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeListFabricScopedID)
                                             params:params];
}

- (void)writeAttributeListFabricScopedWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeListFabricScopedWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeListFabricScopedWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                         params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeListFabricScopedID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeTimedWriteBooleanWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeTimedWriteBooleanID)
                                             params:params];
}

- (void)writeAttributeTimedWriteBooleanWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeTimedWriteBooleanWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeTimedWriteBooleanWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                           expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                          params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeTimedWriteBooleanID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneralErrorBooleanWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeGeneralErrorBooleanID)
                                             params:params];
}

- (void)writeAttributeGeneralErrorBooleanWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeGeneralErrorBooleanWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeGeneralErrorBooleanWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeGeneralErrorBooleanID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterErrorBooleanWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeClusterErrorBooleanID)
                                             params:params];
}

- (void)writeAttributeClusterErrorBooleanWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeClusterErrorBooleanWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeClusterErrorBooleanWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeClusterErrorBooleanID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeUnsupportedWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeUnsupportedID)
                                             params:params];
}

- (void)writeAttributeUnsupportedWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeUnsupportedWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeUnsupportedWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                     expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                    params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeUnsupportedID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableBooleanWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableBooleanID)
                                             params:params];
}

- (void)writeAttributeNullableBooleanWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableBooleanWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableBooleanWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                        params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableBooleanID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableBitmap8WithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableBitmap8ID)
                                             params:params];
}

- (void)writeAttributeNullableBitmap8WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableBitmap8WithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableBitmap8WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                         expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                        params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableBitmap8ID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableBitmap16WithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableBitmap16ID)
                                             params:params];
}

- (void)writeAttributeNullableBitmap16WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableBitmap16WithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableBitmap16WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                         params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableBitmap16ID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableBitmap32WithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableBitmap32ID)
                                             params:params];
}

- (void)writeAttributeNullableBitmap32WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableBitmap32WithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableBitmap32WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                         params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableBitmap32ID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableBitmap64WithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableBitmap64ID)
                                             params:params];
}

- (void)writeAttributeNullableBitmap64WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableBitmap64WithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableBitmap64WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                         params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableBitmap64ID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt8uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt8uID)
                                             params:params];
}

- (void)writeAttributeNullableInt8uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt8uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt8uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt8uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt16uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt16uID)
                                             params:params];
}

- (void)writeAttributeNullableInt16uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt16uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt16uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt16uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt24uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt24uID)
                                             params:params];
}

- (void)writeAttributeNullableInt24uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt24uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt24uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt24uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt32uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt32uID)
                                             params:params];
}

- (void)writeAttributeNullableInt32uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt32uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt32uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt32uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt40uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt40uID)
                                             params:params];
}

- (void)writeAttributeNullableInt40uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt40uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt40uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt40uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt48uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt48uID)
                                             params:params];
}

- (void)writeAttributeNullableInt48uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt48uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt48uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt48uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt56uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt56uID)
                                             params:params];
}

- (void)writeAttributeNullableInt56uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt56uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt56uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt56uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt64uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt64uID)
                                             params:params];
}

- (void)writeAttributeNullableInt64uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt64uWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt64uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt64uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt8sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt8sID)
                                             params:params];
}

- (void)writeAttributeNullableInt8sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt8sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt8sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt8sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt16sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt16sID)
                                             params:params];
}

- (void)writeAttributeNullableInt16sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt16sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt16sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt16sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt24sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt24sID)
                                             params:params];
}

- (void)writeAttributeNullableInt24sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt24sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt24sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt24sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt32sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt32sID)
                                             params:params];
}

- (void)writeAttributeNullableInt32sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt32sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt32sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt32sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt40sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt40sID)
                                             params:params];
}

- (void)writeAttributeNullableInt40sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt40sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt40sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt40sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt48sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt48sID)
                                             params:params];
}

- (void)writeAttributeNullableInt48sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt48sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt48sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt48sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt56sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt56sID)
                                             params:params];
}

- (void)writeAttributeNullableInt56sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt56sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt56sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt56sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableInt64sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableInt64sID)
                                             params:params];
}

- (void)writeAttributeNullableInt64sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableInt64sWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableInt64sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableInt64sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableEnum8WithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableEnum8ID)
                                             params:params];
}

- (void)writeAttributeNullableEnum8WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableEnum8WithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableEnum8WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableEnum8ID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableEnum16WithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableEnum16ID)
                                             params:params];
}

- (void)writeAttributeNullableEnum16WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableEnum16WithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableEnum16WithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableEnum16ID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableFloatSingleWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableFloatSingleID)
                                             params:params];
}

- (void)writeAttributeNullableFloatSingleWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableFloatSingleWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableFloatSingleWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableFloatSingleID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableFloatDoubleWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableFloatDoubleID)
                                             params:params];
}

- (void)writeAttributeNullableFloatDoubleWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableFloatDoubleWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableFloatDoubleWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableFloatDoubleID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableOctetStringWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableOctetStringID)
                                             params:params];
}

- (void)writeAttributeNullableOctetStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableOctetStringWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableOctetStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                             expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                            params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableOctetStringID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableCharStringWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableCharStringID)
                                             params:params];
}

- (void)writeAttributeNullableCharStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableCharStringWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableCharStringWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                            expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                           params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableCharStringID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableEnumAttrWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableEnumAttrID)
                                             params:params];
}

- (void)writeAttributeNullableEnumAttrWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableEnumAttrWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableEnumAttrWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                          expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                         params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableEnumAttrID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableStructWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableStructID)
                                             params:params];
}

- (void)writeAttributeNullableStructWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableStructWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil];
}
- (void)writeAttributeNullableStructWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                        expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                       params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableStructID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableRangeRestrictedInt8uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableRangeRestrictedInt8uID)
                                             params:params];
}

- (void)writeAttributeNullableRangeRestrictedInt8uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableRangeRestrictedInt8uWithValue:dataValueDictionary
                                        expectedValueInterval:expectedValueIntervalMs
                                                       params:nil];
}
- (void)writeAttributeNullableRangeRestrictedInt8uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableRangeRestrictedInt8uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableRangeRestrictedInt8sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableRangeRestrictedInt8sID)
                                             params:params];
}

- (void)writeAttributeNullableRangeRestrictedInt8sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableRangeRestrictedInt8sWithValue:dataValueDictionary
                                        expectedValueInterval:expectedValueIntervalMs
                                                       params:nil];
}
- (void)writeAttributeNullableRangeRestrictedInt8sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                      expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                     params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableRangeRestrictedInt8sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableRangeRestrictedInt16uWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableRangeRestrictedInt16uID)
                                             params:params];
}

- (void)writeAttributeNullableRangeRestrictedInt16uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableRangeRestrictedInt16uWithValue:dataValueDictionary
                                         expectedValueInterval:expectedValueIntervalMs
                                                        params:nil];
}
- (void)writeAttributeNullableRangeRestrictedInt16uWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableRangeRestrictedInt16uID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeNullableRangeRestrictedInt16sWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeNullableRangeRestrictedInt16sID)
                                             params:params];
}

- (void)writeAttributeNullableRangeRestrictedInt16sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
{
    [self writeAttributeNullableRangeRestrictedInt16sWithValue:dataValueDictionary
                                         expectedValueInterval:expectedValueIntervalMs
                                                        params:nil];
}
- (void)writeAttributeNullableRangeRestrictedInt16sWithValue:(NSDictionary<NSString *, id> *)dataValueDictionary
                                       expectedValueInterval:(NSNumber *)expectedValueIntervalMs
                                                      params:(MTRWriteParams * _Nullable)params
{
    NSNumber * waitTimeInMs = params.timedWriteTimeout;

    [self.device writeAttributeWithEndpointId:@(_endpoint)
                                    clusterId:@(MTRClusterTestClusterID)
                                  attributeId:@(MTRClusterTestClusterAttributeNullableRangeRestrictedInt16sID)
                                        value:dataValueDictionary
                        expectedValueInterval:expectedValueIntervalMs
                            timedWriteTimeout:waitTimeInMs];
}

- (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeGeneratedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeAcceptedCommandListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeAttributeListID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeFeatureMapID)
                                             params:params];
}

- (NSDictionary<NSString *, id> *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params
{
    return [self.device readAttributeWithEndpointId:@(_endpoint)
                                          clusterId:@(MTRClusterTestClusterID)
                                        attributeId:@(MTRClusterTestClusterAttributeClusterRevisionID)
                                             params:params];
}

@end

// NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)