/*
 *
 *    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.
 */

#import <Foundation/Foundation.h>

#import "MTRBaseClusters_internal.h"
#import "MTRBaseDevice.h"
#import "MTRBaseDevice_Internal.h"
#import "MTRCallbackBridge_internal.h"
#import "MTRClusterStateCacheContainer_Internal.h"
#import "MTRCluster_internal.h"
#import "MTRCommandPayloadsObjc.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 MTRBaseClusterIdentify

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)identifyWithParams:(MTRIdentifyClusterIdentifyParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)triggerEffectWithParams:(MTRIdentifyClusterTriggerEffectParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeIdentifyTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeIdentifyTimeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeIdentifyTimeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeIdentifyTimeWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeIdentifyTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeIdentifyTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeIdentifyTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeIdentifyTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeIdentifyTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Identify::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<IdentifyGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<IdentifyGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = Identify::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<IdentifyGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Identify::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<IdentifyAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<IdentifyAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Identify::Attributes::AcceptedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<IdentifyAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRIdentifyAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Identify::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<IdentifyAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<IdentifyAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRIdentifyAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Identify::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<IdentifyAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Identify::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Identify::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterGroups

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)addGroupWithParams:(MTRGroupsClusterAddGroupParams *)params
                completion:(void (^)(MTRGroupsClusterAddGroupResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupsClusterAddGroupResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)viewGroupWithParams:(MTRGroupsClusterViewGroupParams *)params
                 completion:
                     (void (^)(MTRGroupsClusterViewGroupResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupsClusterViewGroupResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)getGroupMembershipWithParams:(MTRGroupsClusterGetGroupMembershipParams *)params
                          completion:(void (^)(MTRGroupsClusterGetGroupMembershipResponseParams * _Nullable data,
                                         NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)removeGroupWithParams:(MTRGroupsClusterRemoveGroupParams *)params
                   completion:
                       (void (^)(MTRGroupsClusterRemoveGroupResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupsClusterRemoveGroupResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)removeAllGroupsWithCompletion:(MTRStatusCompletion)completion
{
    [self removeAllGroupsWithParams:nil completion:completion];
}
- (void)removeAllGroupsWithParams:(MTRGroupsClusterRemoveAllGroupsParams * _Nullable)params
                       completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)addGroupIfIdentifyingWithParams:(MTRGroupsClusterAddGroupIfIdentifyingParams *)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeNameSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Groups::Attributes::NameSupport::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNameSupportWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Groups::Attributes::NameSupport::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNameSupportWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Groups::Attributes::NameSupport::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Groups::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<GroupsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Groups::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<GroupsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupsGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Groups::Attributes::GeneratedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<GroupsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Groups::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<GroupsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Groups::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<GroupsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupsAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Groups::Attributes::AcceptedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<GroupsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Groups::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<GroupsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Groups::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<GroupsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupsAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Groups::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<GroupsAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Groups::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Groups::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Groups::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterScenes

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)addSceneWithParams:(MTRScenesClusterAddSceneParams *)params
                completion:(void (^)(MTRScenesClusterAddSceneResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRScenesClusterAddSceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)viewSceneWithParams:(MTRScenesClusterViewSceneParams *)params
                 completion:
                     (void (^)(MTRScenesClusterViewSceneResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRScenesClusterViewSceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)removeSceneWithParams:(MTRScenesClusterRemoveSceneParams *)params
                   completion:
                       (void (^)(MTRScenesClusterRemoveSceneResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRScenesClusterRemoveSceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)removeAllScenesWithParams:(MTRScenesClusterRemoveAllScenesParams *)params
                       completion:(void (^)(MTRScenesClusterRemoveAllScenesResponseParams * _Nullable data,
                                      NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRScenesClusterRemoveAllScenesResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)storeSceneWithParams:(MTRScenesClusterStoreSceneParams *)params
                  completion:
                      (void (^)(MTRScenesClusterStoreSceneResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRScenesClusterStoreSceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)recallSceneWithParams:(MTRScenesClusterRecallSceneParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)getSceneMembershipWithParams:(MTRScenesClusterGetSceneMembershipParams *)params
                          completion:(void (^)(MTRScenesClusterGetSceneMembershipResponseParams * _Nullable data,
                                         NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRScenesClusterGetSceneMembershipResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)enhancedAddSceneWithParams:(MTRScenesClusterEnhancedAddSceneParams *)params
                        completion:(void (^)(MTRScenesClusterEnhancedAddSceneResponseParams * _Nullable data,
                                       NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)enhancedViewSceneWithParams:(MTRScenesClusterEnhancedViewSceneParams *)params
                         completion:(void (^)(MTRScenesClusterEnhancedViewSceneResponseParams * _Nullable data,
                                        NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)copySceneWithParams:(MTRScenesClusterCopySceneParams *)params
                 completion:
                     (void (^)(MTRScenesClusterCopySceneResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRScenesClusterCopySceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)readAttributeSceneCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Scenes::Attributes::SceneCount::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSceneCountWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::SceneCount::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSceneCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Scenes::Attributes::SceneCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentSceneWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Scenes::Attributes::CurrentScene::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentSceneWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::CurrentScene::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentSceneWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Scenes::Attributes::CurrentScene::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentGroupWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Scenes::Attributes::CurrentGroup::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentGroupWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::CurrentGroup::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentGroupWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Scenes::Attributes::CurrentGroup::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSceneValidWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Scenes::Attributes::SceneValid::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSceneValidWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::SceneValid::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSceneValidWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Scenes::Attributes::SceneValid::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNameSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Scenes::Attributes::NameSupport::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNameSupportWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::NameSupport::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNameSupportWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Scenes::Attributes::NameSupport::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLastConfiguredByWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Scenes::Attributes::LastConfiguredBy::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLastConfiguredByWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::LastConfiguredBy::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLastConfiguredByWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Scenes::Attributes::LastConfiguredBy::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRScenesGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Scenes::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ScenesGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ScenesGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRScenesGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Scenes::Attributes::GeneratedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ScenesGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRScenesAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Scenes::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ScenesAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ScenesAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRScenesAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Scenes::Attributes::AcceptedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ScenesAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRScenesAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Scenes::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ScenesAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRScenesAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ScenesAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRScenesAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRScenesAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Scenes::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ScenesAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Scenes::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Scenes::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Scenes::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Scenes::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterOnOff

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)offWithCompletion:(MTRStatusCompletion)completion
{
    [self offWithParams:nil completion:completion];
}
- (void)offWithParams:(MTROnOffClusterOffParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)onWithCompletion:(MTRStatusCompletion)completion
{
    [self onWithParams:nil completion:completion];
}
- (void)onWithParams:(MTROnOffClusterOnParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)toggleWithCompletion:(MTRStatusCompletion)completion
{
    [self toggleWithParams:nil completion:completion];
}
- (void)toggleWithParams:(MTROnOffClusterToggleParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)offWithEffectWithParams:(MTROnOffClusterOffWithEffectParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)onWithRecallGlobalSceneWithCompletion:(MTRStatusCompletion)completion
{
    [self onWithRecallGlobalSceneWithParams:nil completion:completion];
}
- (void)onWithRecallGlobalSceneWithParams:(MTROnOffClusterOnWithRecallGlobalSceneParams * _Nullable)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)onWithTimedOffWithParams:(MTROnOffClusterOnWithTimedOffParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeOnOffWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOff::Attributes::OnOff::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOnOffWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::OnOff::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOnOffWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OnOff::Attributes::OnOff::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGlobalSceneControlWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGlobalSceneControlWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGlobalSceneControlWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOnTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOnTimeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOnTimeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeOnTimeWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOnTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOnTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOffWaitTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOffWaitTimeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOffWaitTimeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeOffWaitTimeWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOffWaitTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOffWaitTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStartUpOnOffWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
            auto successFn = Callback<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeStartUpOnOffWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeStartUpOnOffWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeStartUpOnOffWithValue:(NSNumber * _Nullable)value
                                     params:(MTRWriteParams * _Nullable)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeStartUpOnOffWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
            auto successFn = Callback<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeStartUpOnOffWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROnOffGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOff::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<OnOffGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<OnOffGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROnOffGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OnOff::Attributes::GeneratedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<OnOffGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROnOffAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOff::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<OnOffAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<OnOffAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROnOffAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OnOff::Attributes::AcceptedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<OnOffAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROnOffAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOff::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<OnOffAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROnOffAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<OnOffAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROnOffAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROnOffAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OnOff::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<OnOffAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterOnOffSwitchConfiguration

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeSwitchTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSwitchTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSwitchTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSwitchActionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSwitchActionsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeSwitchActionsWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeSwitchActionsWithValue:(NSNumber * _Nonnull)value
                                      params:(MTRWriteParams * _Nullable)params
                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeSwitchActionsWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSwitchActionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OnOffSwitchConfiguration::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OnOffSwitchConfiguration::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<OnOffSwitchConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<OnOffSwitchConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<OnOffSwitchConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OnOffSwitchConfiguration::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterLevelControl

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)moveToLevelWithParams:(MTRLevelControlClusterMoveToLevelParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)moveWithParams:(MTRLevelControlClusterMoveParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)stepWithParams:(MTRLevelControlClusterStepParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)stopWithParams:(MTRLevelControlClusterStopParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)moveToLevelWithOnOffWithParams:(MTRLevelControlClusterMoveToLevelWithOnOffParams *)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)moveWithOnOffWithParams:(MTRLevelControlClusterMoveWithOnOffParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)stepWithOnOffWithParams:(MTRLevelControlClusterStepWithOnOffParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)stopWithOnOffWithParams:(MTRLevelControlClusterStopWithOnOffParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)moveToClosestFrequencyWithParams:(MTRLevelControlClusterMoveToClosestFrequencyParams *)params
                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeCurrentLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRemainingTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRemainingTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRemainingTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentFrequencyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinFrequencyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxFrequencyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOptionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOptionsWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOptionsWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOptionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOnOffTransitionTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOnOffTransitionTimeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOnOffTransitionTimeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeOnOffTransitionTimeWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOnOffTransitionTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOnOffTransitionTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOnLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOnLevelWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOnLevelWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeOnLevelWithValue:(NSNumber * _Nullable)value
                                params:(MTRWriteParams * _Nullable)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOnLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOnLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOnTransitionTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOnTransitionTimeWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOnTransitionTimeWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeOnTransitionTimeWithValue:(NSNumber * _Nullable)value
                                         params:(MTRWriteParams * _Nullable)params
                                     completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOnTransitionTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOnTransitionTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOffTransitionTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOffTransitionTimeWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOffTransitionTimeWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeOffTransitionTimeWithValue:(NSNumber * _Nullable)value
                                          params:(MTRWriteParams * _Nullable)params
                                      completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOffTransitionTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOffTransitionTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDefaultMoveRateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDefaultMoveRateWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeDefaultMoveRateWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeDefaultMoveRateWithValue:(NSNumber * _Nullable)value
                                        params:(MTRWriteParams * _Nullable)params
                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeDefaultMoveRateWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDefaultMoveRateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStartUpCurrentLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeStartUpCurrentLevelWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeStartUpCurrentLevelWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeStartUpCurrentLevelWithValue:(NSNumber * _Nullable)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeStartUpCurrentLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeStartUpCurrentLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<LevelControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<LevelControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = LevelControl::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<LevelControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<LevelControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<LevelControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = LevelControl::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<LevelControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLevelControlAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<LevelControlAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<LevelControlAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLevelControlAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<LevelControlAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBinaryInputBasic

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeActiveTextWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActiveTextWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeActiveTextWithValue:(NSString * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeActiveTextWithValue:(NSString * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeActiveTextWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActiveTextWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDescriptionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDescriptionWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeDescriptionWithValue:(NSString * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeDescriptionWithValue:(NSString * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeDescriptionWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDescriptionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInactiveTextWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInactiveTextWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInactiveTextWithValue:(NSString * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInactiveTextWithValue:(NSString * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInactiveTextWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInactiveTextWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOutOfServiceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOutOfServiceWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOutOfServiceWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeOutOfServiceWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOutOfServiceWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOutOfServiceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePolarityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::Polarity::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePolarityWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::Polarity::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePolarityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BinaryInputBasic::Attributes::Polarity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePresentValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePresentValueWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributePresentValueWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributePresentValueWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributePresentValueWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePresentValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReliabilityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeReliabilityWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeReliabilityWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeReliabilityWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeReliabilityWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeReliabilityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStatusFlagsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeStatusFlagsWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeStatusFlagsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeApplicationTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::ApplicationType::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeApplicationTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::ApplicationType::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeApplicationTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BinaryInputBasic::Attributes::ApplicationType::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BinaryInputBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BinaryInputBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = BinaryInputBasic::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<BinaryInputBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BinaryInputBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BinaryInputBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = BinaryInputBasic::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<BinaryInputBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BinaryInputBasicAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BinaryInputBasicAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = BinaryInputBasic::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<BinaryInputBasicAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BinaryInputBasic::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterDescriptor

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeDeviceTypeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorDeviceTypeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Descriptor::Attributes::DeviceTypeList::TypeInfo;
            auto successFn = Callback<DescriptorDeviceTypeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDeviceTypeListWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::DeviceTypeList::TypeInfo;
            auto successFn = Callback<DescriptorDeviceTypeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDeviceTypeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorDeviceTypeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Descriptor::Attributes::DeviceTypeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<DescriptorDeviceTypeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeServerListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorServerListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo;
            auto successFn = Callback<DescriptorServerListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeServerListWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDescriptorServerListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo;
            auto successFn = Callback<DescriptorServerListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorServerListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeServerListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorServerListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<DescriptorServerListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClientListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorClientListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo;
            auto successFn = Callback<DescriptorClientListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClientListWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDescriptorClientListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo;
            auto successFn = Callback<DescriptorClientListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorClientListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClientListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorClientListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<DescriptorClientListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePartsListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorPartsListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo;
            auto successFn = Callback<DescriptorPartsListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePartsListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo;
            auto successFn = Callback<DescriptorPartsListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePartsListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorPartsListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<DescriptorPartsListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Descriptor::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<DescriptorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<DescriptorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = Descriptor::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<DescriptorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Descriptor::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<DescriptorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<DescriptorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = Descriptor::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<DescriptorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Descriptor::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<DescriptorAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<DescriptorAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDescriptorAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Descriptor::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<DescriptorAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Descriptor::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Descriptor::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBinding

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeBindingWithParams:(MTRReadParams * _Nullable)params
                            completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{ // Make a copy of params before we go async.
    params = [params copy];
    new MTRBindingBindingListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Binding::Attributes::Binding::TypeInfo;
            auto successFn = Callback<BindingBindingListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(
                successFn->mContext, successFn->mCall, failureFn->mCall, params.fabricFiltered);
        });
}

- (void)writeAttributeBindingWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBindingWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeBindingWithValue:(NSArray * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Binding::Attributes::Binding::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.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 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[MTRBindingClusterTargetStruct class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (MTRBindingClusterTargetStruct *) value[i_0];
                        if (element_0.node != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].node.Emplace();
                            definedValue_2 = element_0.node.unsignedLongLongValue;
                        }
                        if (element_0.group != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].group.Emplace();
                            definedValue_2 = element_0.group.unsignedShortValue;
                        }
                        if (element_0.endpoint != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].endpoint.Emplace();
                            definedValue_2 = element_0.endpoint.unsignedShortValue;
                        }
                        if (element_0.cluster != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].cluster.Emplace();
                            definedValue_2 = element_0.cluster.unsignedIntValue;
                        }
                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBindingWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBindingBindingListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Binding::Attributes::Binding::TypeInfo;
            auto successFn = Callback<BindingBindingListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBindingBindingListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBindingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBindingBindingListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Binding::Attributes::Binding::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BindingBindingListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBindingGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Binding::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BindingGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Binding::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BindingGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBindingGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Binding::Attributes::GeneratedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BindingGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBindingAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Binding::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BindingAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Binding::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BindingAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBindingAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Binding::Attributes::AcceptedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BindingAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBindingAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Binding::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BindingAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBindingAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Binding::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BindingAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBindingAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBindingAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Binding::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BindingAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Binding::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Binding::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Binding::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterAccessControl

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeACLWithParams:(MTRReadParams * _Nullable)params
                        completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{ // Make a copy of params before we go async.
    params = [params copy];
    new MTRAccessControlACLListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
            auto successFn = Callback<AccessControlACLListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(
                successFn->mContext, successFn->mCall, failureFn->mCall, params.fabricFiltered);
        });
}

- (void)writeAttributeACLWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeACLWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeACLWithValue:(NSArray * _Nonnull)value
                            params:(MTRWriteParams * _Nullable)params
                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.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 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[MTRAccessControlClusterAccessControlEntry class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (MTRAccessControlClusterAccessControlEntry *) value[i_0];
                        listHolder_0->mList[i_0].privilege
                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].privilege)>>(
                                element_0.privilege.unsignedCharValue);
                        listHolder_0->mList[i_0].authMode
                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].authMode)>>(
                                element_0.authMode.unsignedCharValue);
                        if (element_0.subjects == nil) {
                            listHolder_0->mList[i_0].subjects.SetNull();
                        } else {
                            auto & nonNullValue_2 = listHolder_0->mList[i_0].subjects.SetNonNull();
                            {
                                using ListType_3 = std::remove_reference_t<decltype(nonNullValue_2)>;
                                using ListMemberType_3 = ListMemberTypeGetter<ListType_3>::Type;
                                if (element_0.subjects.count != 0) {
                                    auto * listHolder_3 = new ListHolder<ListMemberType_3>(element_0.subjects.count);
                                    if (listHolder_3 == nullptr || listHolder_3->mList == nullptr) {
                                        return CHIP_ERROR_INVALID_ARGUMENT;
                                    }
                                    listFreer.add(listHolder_3);
                                    for (size_t i_3 = 0; i_3 < element_0.subjects.count; ++i_3) {
                                        if (![element_0.subjects[i_3] isKindOfClass:[NSNumber class]]) {
                                            // Wrong kind of value.
                                            return CHIP_ERROR_INVALID_ARGUMENT;
                                        }
                                        auto element_3 = (NSNumber *) element_0.subjects[i_3];
                                        listHolder_3->mList[i_3] = element_3.unsignedLongLongValue;
                                    }
                                    nonNullValue_2 = ListType_3(listHolder_3->mList, element_0.subjects.count);
                                } else {
                                    nonNullValue_2 = ListType_3();
                                }
                            }
                        }
                        if (element_0.targets == nil) {
                            listHolder_0->mList[i_0].targets.SetNull();
                        } else {
                            auto & nonNullValue_2 = listHolder_0->mList[i_0].targets.SetNonNull();
                            {
                                using ListType_3 = std::remove_reference_t<decltype(nonNullValue_2)>;
                                using ListMemberType_3 = ListMemberTypeGetter<ListType_3>::Type;
                                if (element_0.targets.count != 0) {
                                    auto * listHolder_3 = new ListHolder<ListMemberType_3>(element_0.targets.count);
                                    if (listHolder_3 == nullptr || listHolder_3->mList == nullptr) {
                                        return CHIP_ERROR_INVALID_ARGUMENT;
                                    }
                                    listFreer.add(listHolder_3);
                                    for (size_t i_3 = 0; i_3 < element_0.targets.count; ++i_3) {
                                        if (![element_0.targets[i_3] isKindOfClass:[MTRAccessControlClusterTarget class]]) {
                                            // Wrong kind of value.
                                            return CHIP_ERROR_INVALID_ARGUMENT;
                                        }
                                        auto element_3 = (MTRAccessControlClusterTarget *) element_0.targets[i_3];
                                        if (element_3.cluster == nil) {
                                            listHolder_3->mList[i_3].cluster.SetNull();
                                        } else {
                                            auto & nonNullValue_5 = listHolder_3->mList[i_3].cluster.SetNonNull();
                                            nonNullValue_5 = element_3.cluster.unsignedIntValue;
                                        }
                                        if (element_3.endpoint == nil) {
                                            listHolder_3->mList[i_3].endpoint.SetNull();
                                        } else {
                                            auto & nonNullValue_5 = listHolder_3->mList[i_3].endpoint.SetNonNull();
                                            nonNullValue_5 = element_3.endpoint.unsignedShortValue;
                                        }
                                        if (element_3.deviceType == nil) {
                                            listHolder_3->mList[i_3].deviceType.SetNull();
                                        } else {
                                            auto & nonNullValue_5 = listHolder_3->mList[i_3].deviceType.SetNonNull();
                                            nonNullValue_5 = element_3.deviceType.unsignedIntValue;
                                        }
                                    }
                                    nonNullValue_2 = ListType_3(listHolder_3->mList, element_0.targets.count);
                                } else {
                                    nonNullValue_2 = ListType_3();
                                }
                            }
                        }
                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeACLWithParams:(MTRSubscribeParams * _Nonnull)params
                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAccessControlACLListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
            auto successFn = Callback<AccessControlACLListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccessControlACLListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeACLWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccessControlACLListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<AccessControlACLListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeExtensionWithParams:(MTRReadParams * _Nullable)params
                              completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{ // Make a copy of params before we go async.
    params = [params copy];
    new MTRAccessControlExtensionListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
            auto successFn = Callback<AccessControlExtensionListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(
                successFn->mContext, successFn->mCall, failureFn->mCall, params.fabricFiltered);
        });
}

- (void)writeAttributeExtensionWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeExtensionWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeExtensionWithValue:(NSArray * _Nonnull)value
                                  params:(MTRWriteParams * _Nullable)params
                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.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 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[MTRAccessControlClusterExtensionEntry class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (MTRAccessControlClusterExtensionEntry *) value[i_0];
                        listHolder_0->mList[i_0].data = [self asByteSpan:element_0.data];
                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeExtensionWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
            auto successFn = Callback<AccessControlExtensionListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeExtensionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccessControlExtensionListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<AccessControlExtensionListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSubjectsPerAccessControlEntryWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccessControl::Attributes::SubjectsPerAccessControlEntry::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSubjectsPerAccessControlEntryWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::SubjectsPerAccessControlEntry::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSubjectsPerAccessControlEntryWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AccessControl::Attributes::SubjectsPerAccessControlEntry::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTargetsPerAccessControlEntryWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccessControl::Attributes::TargetsPerAccessControlEntry::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTargetsPerAccessControlEntryWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::TargetsPerAccessControlEntry::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTargetsPerAccessControlEntryWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AccessControl::Attributes::TargetsPerAccessControlEntry::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAccessControlEntriesPerFabricWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccessControl::Attributes::AccessControlEntriesPerFabric::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAccessControlEntriesPerFabricWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::AccessControlEntriesPerFabric::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAccessControlEntriesPerFabricWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AccessControl::Attributes::AccessControlEntriesPerFabric::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccessControl::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<AccessControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<AccessControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = AccessControl::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<AccessControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccessControl::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<AccessControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<AccessControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = AccessControl::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<AccessControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccessControlAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<AccessControlAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<AccessControlAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccessControlAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<AccessControlAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccessControl::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AccessControl::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterActions

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)instantActionWithParams:(MTRActionsClusterInstantActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Actions::Commands::InstantAction::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }
            request.actionID = params.actionID.unsignedShortValue;
            if (params.invokeID != nil) {
                auto & definedValue_0 = request.invokeID.Emplace();
                definedValue_0 = params.invokeID.unsignedIntValue;
            }

            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
        });
}

- (void)instantActionWithTransitionWithParams:(MTRActionsClusterInstantActionWithTransitionParams *)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Actions::Commands::InstantActionWithTransition::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }
            request.actionID = params.actionID.unsignedShortValue;
            if (params.invokeID != nil) {
                auto & definedValue_0 = request.invokeID.Emplace();
                definedValue_0 = params.invokeID.unsignedIntValue;
            }
            request.transitionTime = params.transitionTime.unsignedShortValue;

            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
        });
}

- (void)startActionWithParams:(MTRActionsClusterStartActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Actions::Commands::StartAction::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }
            request.actionID = params.actionID.unsignedShortValue;
            if (params.invokeID != nil) {
                auto & definedValue_0 = request.invokeID.Emplace();
                definedValue_0 = params.invokeID.unsignedIntValue;
            }

            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
        });
}

- (void)startActionWithDurationWithParams:(MTRActionsClusterStartActionWithDurationParams *)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Actions::Commands::StartActionWithDuration::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }
            request.actionID = params.actionID.unsignedShortValue;
            if (params.invokeID != nil) {
                auto & definedValue_0 = request.invokeID.Emplace();
                definedValue_0 = params.invokeID.unsignedIntValue;
            }
            request.duration = params.duration.unsignedIntValue;

            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
        });
}

- (void)stopActionWithParams:(MTRActionsClusterStopActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Actions::Commands::StopAction::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }
            request.actionID = params.actionID.unsignedShortValue;
            if (params.invokeID != nil) {
                auto & definedValue_0 = request.invokeID.Emplace();
                definedValue_0 = params.invokeID.unsignedIntValue;
            }

            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
        });
}

- (void)pauseActionWithParams:(MTRActionsClusterPauseActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Actions::Commands::PauseAction::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }
            request.actionID = params.actionID.unsignedShortValue;
            if (params.invokeID != nil) {
                auto & definedValue_0 = request.invokeID.Emplace();
                definedValue_0 = params.invokeID.unsignedIntValue;
            }

            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
        });
}

- (void)pauseActionWithDurationWithParams:(MTRActionsClusterPauseActionWithDurationParams *)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Actions::Commands::PauseActionWithDuration::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }
            request.actionID = params.actionID.unsignedShortValue;
            if (params.invokeID != nil) {
                auto & definedValue_0 = request.invokeID.Emplace();
                definedValue_0 = params.invokeID.unsignedIntValue;
            }
            request.duration = params.duration.unsignedIntValue;

            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
        });
}

- (void)resumeActionWithParams:(MTRActionsClusterResumeActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Actions::Commands::ResumeAction::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }
            request.actionID = params.actionID.unsignedShortValue;
            if (params.invokeID != nil) {
                auto & definedValue_0 = request.invokeID.Emplace();
                definedValue_0 = params.invokeID.unsignedIntValue;
            }

            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
        });
}

- (void)enableActionWithParams:(MTRActionsClusterEnableActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Actions::Commands::EnableAction::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }
            request.actionID = params.actionID.unsignedShortValue;
            if (params.invokeID != nil) {
                auto & definedValue_0 = request.invokeID.Emplace();
                definedValue_0 = params.invokeID.unsignedIntValue;
            }

            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
        });
}

- (void)enableActionWithDurationWithParams:(MTRActionsClusterEnableActionWithDurationParams *)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Actions::Commands::EnableActionWithDuration::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }
            request.actionID = params.actionID.unsignedShortValue;
            if (params.invokeID != nil) {
                auto & definedValue_0 = request.invokeID.Emplace();
                definedValue_0 = params.invokeID.unsignedIntValue;
            }
            request.duration = params.duration.unsignedIntValue;

            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
        });
}

- (void)disableActionWithParams:(MTRActionsClusterDisableActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Actions::Commands::DisableAction::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }
            request.actionID = params.actionID.unsignedShortValue;
            if (params.invokeID != nil) {
                auto & definedValue_0 = request.invokeID.Emplace();
                definedValue_0 = params.invokeID.unsignedIntValue;
            }

            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
        });
}

- (void)disableActionWithDurationWithParams:(MTRActionsClusterDisableActionWithDurationParams *)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Actions::Commands::DisableActionWithDuration::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }
            request.actionID = params.actionID.unsignedShortValue;
            if (params.invokeID != nil) {
                auto & definedValue_0 = request.invokeID.Emplace();
                definedValue_0 = params.invokeID.unsignedIntValue;
            }
            request.duration = params.duration.unsignedIntValue;

            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
        });
}

- (void)readAttributeActionListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRActionsActionListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Actions::Attributes::ActionList::TypeInfo;
            auto successFn = Callback<ActionsActionListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActionListWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRActionsActionListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::ActionList::TypeInfo;
            auto successFn = Callback<ActionsActionListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRActionsActionListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActionListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRActionsActionListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Actions::Attributes::ActionList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ActionsActionListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEndpointListsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRActionsEndpointListsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Actions::Attributes::EndpointLists::TypeInfo;
            auto successFn = Callback<ActionsEndpointListsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeEndpointListsWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::EndpointLists::TypeInfo;
            auto successFn = Callback<ActionsEndpointListsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEndpointListsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRActionsEndpointListsListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Actions::Attributes::EndpointLists::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ActionsEndpointListsListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSetupURLWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Actions::Attributes::SetupURL::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSetupURLWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::SetupURL::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSetupURLWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Actions::Attributes::SetupURL::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRActionsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Actions::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ActionsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ActionsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRActionsGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Actions::Attributes::GeneratedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ActionsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRActionsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Actions::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ActionsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ActionsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRActionsAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Actions::Attributes::AcceptedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ActionsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRActionsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Actions::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ActionsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRActionsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ActionsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRActionsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRActionsAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Actions::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ActionsAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Actions::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Actions::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Actions::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Actions::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBasic

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)mfgSpecificPingWithCompletion:(MTRStatusCompletion)completion
{
    [self mfgSpecificPingWithParams:nil completion:completion];
}
- (void)mfgSpecificPingWithParams:(MTRBasicClusterMfgSpecificPingParams * _Nullable)params
                       completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeDataModelRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::DataModelRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDataModelRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::DataModelRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDataModelRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::DataModelRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeVendorNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::VendorName::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeVendorNameWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::VendorName::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeVendorNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::VendorName::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeVendorIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::VendorID::TypeInfo;
            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeVendorIDWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRVendorIdAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::VendorID::TypeInfo;
            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeVendorIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::VendorID::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::ProductName::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeProductNameWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::ProductName::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeProductNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::ProductName::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::ProductID::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeProductIDWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::ProductID::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeProductIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::ProductID::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNodeLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNodeLabelWithValue:(NSString * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value
                                  params:(MTRWriteParams * _Nullable)params
                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNodeLabelWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNodeLabelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLocationWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::Location::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLocationWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLocationWithValue:(NSString * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeLocationWithValue:(NSString * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::Location::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLocationWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::Location::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLocationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::Location::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeHardwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::HardwareVersion::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeHardwareVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::HardwareVersion::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeHardwareVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::HardwareVersion::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeHardwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::HardwareVersionString::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeHardwareVersionStringWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::HardwareVersionString::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeHardwareVersionStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::HardwareVersionString::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSoftwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::SoftwareVersion::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSoftwareVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::SoftwareVersion::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSoftwareVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::SoftwareVersion::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSoftwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::SoftwareVersionString::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSoftwareVersionStringWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::SoftwareVersionString::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSoftwareVersionStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::SoftwareVersionString::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeManufacturingDateWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::ManufacturingDate::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeManufacturingDateWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::ManufacturingDate::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeManufacturingDateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::ManufacturingDate::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePartNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::PartNumber::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePartNumberWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::PartNumber::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePartNumberWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::PartNumber::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductURLWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::ProductURL::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeProductURLWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::ProductURL::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeProductURLWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::ProductURL::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::ProductLabel::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeProductLabelWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::ProductLabel::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeProductLabelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::ProductLabel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSerialNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::SerialNumber::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSerialNumberWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::SerialNumber::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSerialNumberWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::SerialNumber::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLocalConfigDisabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::LocalConfigDisabled::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLocalConfigDisabledWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLocalConfigDisabledWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeLocalConfigDisabledWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::LocalConfigDisabled::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLocalConfigDisabledWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::LocalConfigDisabled::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLocalConfigDisabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::LocalConfigDisabled::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReachableWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::Reachable::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeReachableWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::Reachable::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeReachableWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::Reachable::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUniqueIDWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::UniqueID::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeUniqueIDWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::UniqueID::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUniqueIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::UniqueID::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCapabilityMinimaWithCompletion:(void (^)(MTRBasicClusterCapabilityMinimaStruct * _Nullable value,
                                                        NSError * _Nullable error))completion
{
    new MTRBasicCapabilityMinimaStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::CapabilityMinima::TypeInfo;
            auto successFn = Callback<BasicCapabilityMinimaStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCapabilityMinimaWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(MTRBasicClusterCapabilityMinimaStruct * _Nullable value,
                                                         NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::CapabilityMinima::TypeInfo;
            auto successFn = Callback<BasicCapabilityMinimaStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCapabilityMinimaWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:(void (^)(MTRBasicClusterCapabilityMinimaStruct * _Nullable value,
                                                               NSError * _Nullable error))completion
{
    new MTRBasicCapabilityMinimaStructAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::CapabilityMinima::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BasicCapabilityMinimaStructAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBasicGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::GeneratedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBasicAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::AcceptedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BasicAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBasicAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BasicAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBasicAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BasicAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Basic::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Basic::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterOTASoftwareUpdateProvider

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)queryImageWithParams:(MTROTASoftwareUpdateProviderClusterQueryImageParams *)params
                  completion:(void (^)(MTROTASoftwareUpdateProviderClusterQueryImageResponseParams * _Nullable data,
                                 NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROTASoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)applyUpdateRequestWithParams:(MTROTASoftwareUpdateProviderClusterApplyUpdateRequestParams *)params
                          completion:(void (^)(MTROTASoftwareUpdateProviderClusterApplyUpdateResponseParams * _Nullable data,
                                         NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROTASoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)notifyUpdateAppliedWithParams:(MTROTASoftwareUpdateProviderClusterNotifyUpdateAppliedParams *)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateProviderGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateProviderGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OtaSoftwareUpdateProvider::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<OTASoftwareUpdateProviderGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateProviderAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateProviderAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<OTASoftwareUpdateProviderAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateProviderAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateProviderAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<OTASoftwareUpdateProviderAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterOTASoftwareUpdateRequestor

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)announceOtaProviderWithParams:(MTROTASoftwareUpdateRequestorClusterAnnounceOtaProviderParams *)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeDefaultOtaProvidersWithParams:(MTRReadParams * _Nullable)params
                                        completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{ // Make a copy of params before we go async.
    params = [params copy];
    new MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOtaProviders::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(
                successFn->mContext, successFn->mCall, failureFn->mCall, params.fabricFiltered);
        });
}

- (void)writeAttributeDefaultOtaProvidersWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeDefaultOtaProvidersWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeDefaultOtaProvidersWithValue:(NSArray * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOtaProviders::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.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 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[MTROTASoftwareUpdateRequestorClusterProviderLocation class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (MTROTASoftwareUpdateRequestorClusterProviderLocation *) value[i_0];
                        listHolder_0->mList[i_0].providerNodeID = element_0.providerNodeID.unsignedLongLongValue;
                        listHolder_0->mList[i_0].endpoint = element_0.endpoint.unsignedShortValue;
                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeDefaultOtaProvidersWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOtaProviders::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDefaultOtaProvidersWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOtaProviders::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<OTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeUpdatePossibleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeUpdatePossibleWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUpdatePossibleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUpdateStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;
            auto successFn
                = Callback<OTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeUpdateStateWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;
            auto successFn
                = Callback<OTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUpdateStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<OTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeUpdateStateProgressWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateStateProgress::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeUpdateStateProgressWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateStateProgress::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUpdateStateProgressWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateStateProgress::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<OTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<OTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateRequestorAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<OTASoftwareUpdateRequestorAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<OTASoftwareUpdateRequestorAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterLocalizationConfiguration

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeActiveLocaleWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActiveLocaleWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeActiveLocaleWithValue:(NSString * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeActiveLocaleWithValue:(NSString * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeActiveLocaleWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActiveLocaleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSupportedLocalesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LocalizationConfiguration::Attributes::SupportedLocales::TypeInfo;
            auto successFn = Callback<LocalizationConfigurationSupportedLocalesListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSupportedLocalesWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::SupportedLocales::TypeInfo;
            auto successFn = Callback<LocalizationConfigurationSupportedLocalesListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSupportedLocalesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = LocalizationConfiguration::Attributes::SupportedLocales::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<LocalizationConfigurationSupportedLocalesListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LocalizationConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<LocalizationConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<LocalizationConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = LocalizationConfiguration::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<LocalizationConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LocalizationConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<LocalizationConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<LocalizationConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = LocalizationConfiguration::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<LocalizationConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LocalizationConfiguration::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<LocalizationConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<LocalizationConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = LocalizationConfiguration::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<LocalizationConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LocalizationConfiguration::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LocalizationConfiguration::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LocalizationConfiguration::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LocalizationConfiguration::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterTimeFormatLocalization

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeHourFormatWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
            auto successFn = Callback<TimeFormatLocalizationClusterHourFormatAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeHourFormatWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeHourFormatWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeHourFormatWithValue:(NSNumber * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeHourFormatWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
            auto successFn = Callback<TimeFormatLocalizationClusterHourFormatAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeHourFormatWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TimeFormatLocalizationClusterHourFormatAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeActiveCalendarTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
            auto successFn = Callback<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActiveCalendarTypeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeActiveCalendarTypeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeActiveCalendarTypeWithValue:(NSNumber * _Nonnull)value
                                           params:(MTRWriteParams * _Nullable)params
                                       completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeActiveCalendarTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
            auto successFn = Callback<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActiveCalendarTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeSupportedCalendarTypesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TimeFormatLocalization::Attributes::SupportedCalendarTypes::TypeInfo;
            auto successFn = Callback<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSupportedCalendarTypesWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::SupportedCalendarTypes::TypeInfo;
            auto successFn = Callback<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSupportedCalendarTypesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:
                                                          (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TimeFormatLocalization::Attributes::SupportedCalendarTypes::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TimeFormatLocalization::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TimeFormatLocalization::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TimeFormatLocalization::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TimeFormatLocalization::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TimeFormatLocalization::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<TimeFormatLocalizationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<TimeFormatLocalizationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TimeFormatLocalization::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TimeFormatLocalizationAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TimeFormatLocalization::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TimeFormatLocalization::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TimeFormatLocalization::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TimeFormatLocalization::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterUnitLocalization

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeTemperatureUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
            auto successFn = Callback<UnitLocalizationClusterTempUnitAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTemperatureUnitWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeTemperatureUnitWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeTemperatureUnitWithValue:(NSNumber * _Nonnull)value
                                        params:(MTRWriteParams * _Nullable)params
                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeTemperatureUnitWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
            auto successFn = Callback<UnitLocalizationClusterTempUnitAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTemperatureUnitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<UnitLocalizationClusterTempUnitAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = UnitLocalization::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<UnitLocalizationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UnitLocalization::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<UnitLocalizationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = UnitLocalization::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<UnitLocalizationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = UnitLocalization::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<UnitLocalizationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UnitLocalization::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<UnitLocalizationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = UnitLocalization::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<UnitLocalizationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUnitLocalizationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = UnitLocalization::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<UnitLocalizationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UnitLocalization::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<UnitLocalizationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUnitLocalizationAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = UnitLocalization::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<UnitLocalizationAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = UnitLocalization::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UnitLocalization::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = UnitLocalization::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = UnitLocalization::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UnitLocalization::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = UnitLocalization::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterPowerSourceConfiguration

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeSourcesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo;
            auto successFn = Callback<PowerSourceConfigurationSourcesListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSourcesWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo;
            auto successFn = Callback<PowerSourceConfigurationSourcesListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSourcesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PowerSourceConfigurationSourcesListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSourceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSourceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PowerSourceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSourceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSourceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PowerSourceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<PowerSourceConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<PowerSourceConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PowerSourceConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSourceConfiguration::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSourceConfiguration::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSourceConfiguration::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterPowerSource

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::Status::TypeInfo;
            auto successFn = Callback<PowerSourceClusterPowerSourceStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::Status::TypeInfo;
            auto successFn = Callback<PowerSourceClusterPowerSourceStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PowerSource::Attributes::Status::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PowerSourceClusterPowerSourceStatusAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeOrderWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::Order::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOrderWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::Order::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOrderWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::Order::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDescriptionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::Description::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDescriptionWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::Description::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDescriptionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::Description::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWiredAssessedInputVoltageWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::WiredAssessedInputVoltage::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeWiredAssessedInputVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredAssessedInputVoltage::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWiredAssessedInputVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::WiredAssessedInputVoltage::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWiredAssessedInputFrequencyWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::WiredAssessedInputFrequency::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeWiredAssessedInputFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredAssessedInputFrequency::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWiredAssessedInputFrequencyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                             endpoint:(NSNumber *)endpoint
                                                                queue:(dispatch_queue_t)queue
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::WiredAssessedInputFrequency::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWiredCurrentTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::WiredCurrentType::TypeInfo;
            auto successFn = Callback<PowerSourceClusterWiredCurrentTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeWiredCurrentTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredCurrentType::TypeInfo;
            auto successFn = Callback<PowerSourceClusterWiredCurrentTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWiredCurrentTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PowerSource::Attributes::WiredCurrentType::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PowerSourceClusterWiredCurrentTypeAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeWiredAssessedCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::WiredAssessedCurrent::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeWiredAssessedCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredAssessedCurrent::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWiredAssessedCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::WiredAssessedCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWiredNominalVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::WiredNominalVoltage::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeWiredNominalVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredNominalVoltage::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWiredNominalVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::WiredNominalVoltage::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWiredMaximumCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::WiredMaximumCurrent::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeWiredMaximumCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredMaximumCurrent::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWiredMaximumCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::WiredMaximumCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWiredPresentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::WiredPresent::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeWiredPresentWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredPresent::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWiredPresentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::WiredPresent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveWiredFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::ActiveWiredFaults::TypeInfo;
            auto successFn = Callback<PowerSourceActiveWiredFaultsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActiveWiredFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::ActiveWiredFaults::TypeInfo;
            auto successFn = Callback<PowerSourceActiveWiredFaultsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActiveWiredFaultsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PowerSource::Attributes::ActiveWiredFaults::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PowerSourceActiveWiredFaultsListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeBatVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatVoltage::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatVoltage::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatVoltage::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatPercentRemainingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatPercentRemaining::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatPercentRemainingWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatPercentRemaining::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatPercentRemainingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatPercentRemaining::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatTimeRemainingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatTimeRemaining::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatTimeRemainingWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatTimeRemaining::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatTimeRemainingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatTimeRemaining::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatChargeLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatChargeLevel::TypeInfo;
            auto successFn = Callback<PowerSourceClusterBatChargeLevelAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatChargeLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatChargeLevel::TypeInfo;
            auto successFn = Callback<PowerSourceClusterBatChargeLevelAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatChargeLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PowerSource::Attributes::BatChargeLevel::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PowerSourceClusterBatChargeLevelAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeBatReplacementNeededWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatReplacementNeeded::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatReplacementNeededWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatReplacementNeeded::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatReplacementNeededWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatReplacementNeeded::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatReplaceabilityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatReplaceability::TypeInfo;
            auto successFn = Callback<PowerSourceClusterBatReplaceabilityAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatReplaceabilityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatReplaceability::TypeInfo;
            auto successFn = Callback<PowerSourceClusterBatReplaceabilityAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatReplaceabilityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PowerSource::Attributes::BatReplaceability::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PowerSourceClusterBatReplaceabilityAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeBatPresentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatPresent::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatPresentWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatPresent::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatPresentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatPresent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveBatFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::ActiveBatFaults::TypeInfo;
            auto successFn = Callback<PowerSourceActiveBatFaultsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActiveBatFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::ActiveBatFaults::TypeInfo;
            auto successFn = Callback<PowerSourceActiveBatFaultsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActiveBatFaultsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::ActiveBatFaults::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<PowerSourceActiveBatFaultsListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatReplacementDescriptionWithCompletion:(void (^)(
                                                                 NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatReplacementDescription::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatReplacementDescriptionWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:
                                                    (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatReplacementDescription::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatReplacementDescriptionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSString * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatReplacementDescription::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatCommonDesignationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatCommonDesignation::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatCommonDesignationWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatCommonDesignation::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatCommonDesignationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatCommonDesignation::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatANSIDesignationWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatANSIDesignation::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatANSIDesignationWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatANSIDesignation::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatANSIDesignationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatANSIDesignation::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatIECDesignationWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatIECDesignation::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatIECDesignationWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatIECDesignation::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatIECDesignationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatIECDesignation::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatApprovedChemistryWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatApprovedChemistry::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatApprovedChemistryWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatApprovedChemistry::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatApprovedChemistryWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatApprovedChemistry::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatCapacity::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatCapacityWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatCapacity::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatCapacityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatCapacity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatQuantityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatQuantity::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatQuantityWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatQuantity::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatQuantityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatQuantity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatChargeStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatChargeState::TypeInfo;
            auto successFn = Callback<PowerSourceClusterBatChargeStateAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatChargeStateWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatChargeState::TypeInfo;
            auto successFn = Callback<PowerSourceClusterBatChargeStateAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatChargeStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PowerSource::Attributes::BatChargeState::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PowerSourceClusterBatChargeStateAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeBatTimeToFullChargeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatTimeToFullCharge::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatTimeToFullChargeWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatTimeToFullCharge::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatTimeToFullChargeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatTimeToFullCharge::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatFunctionalWhileChargingWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatFunctionalWhileCharging::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatFunctionalWhileChargingWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatFunctionalWhileCharging::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatFunctionalWhileChargingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatFunctionalWhileCharging::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatChargingCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::BatChargingCurrent::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBatChargingCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatChargingCurrent::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBatChargingCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::BatChargingCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveBatChargeFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::ActiveBatChargeFaults::TypeInfo;
            auto successFn = Callback<PowerSourceActiveBatChargeFaultsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActiveBatChargeFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::ActiveBatChargeFaults::TypeInfo;
            auto successFn = Callback<PowerSourceActiveBatChargeFaultsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActiveBatChargeFaultsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PowerSource::Attributes::ActiveBatChargeFaults::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PowerSourceActiveBatChargeFaultsListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<PowerSourceGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<PowerSourceGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PowerSource::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PowerSourceGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<PowerSourceAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<PowerSourceAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PowerSource::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PowerSourceAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<PowerSourceAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<PowerSourceAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPowerSourceAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<PowerSourceAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterGeneralCommissioning

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)armFailSafeWithParams:(MTRGeneralCommissioningClusterArmFailSafeParams *)params
                   completion:(void (^)(MTRGeneralCommissioningClusterArmFailSafeResponseParams * _Nullable data,
                                  NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)setRegulatoryConfigWithParams:(MTRGeneralCommissioningClusterSetRegulatoryConfigParams *)params
                           completion:(void (^)(MTRGeneralCommissioningClusterSetRegulatoryConfigResponseParams * _Nullable data,
                                          NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)commissioningCompleteWithCompletion:(void (^)(
                                                MTRGeneralCommissioningClusterCommissioningCompleteResponseParams * _Nullable data,
                                                NSError * _Nullable error))completion
{
    [self commissioningCompleteWithParams:nil completion:completion];
}
- (void)commissioningCompleteWithParams:(MTRGeneralCommissioningClusterCommissioningCompleteParams * _Nullable)params
                             completion:
                                 (void (^)(MTRGeneralCommissioningClusterCommissioningCompleteResponseParams * _Nullable data,
                                     NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)readAttributeBreadcrumbWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBreadcrumbWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBreadcrumbWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeBreadcrumbWithValue:(NSNumber * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBreadcrumbWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBreadcrumbWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBasicCommissioningInfoWithCompletion:
    (void (^)(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfo::TypeInfo;
            auto successFn = Callback<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBasicCommissioningInfoWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value,
                                                     NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfo::TypeInfo;
            auto successFn = Callback<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)
    readAttributeBasicCommissioningInfoWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(
                                                          MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value,
                                                          NSError * _Nullable error))completion
{
    new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfo::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeRegulatoryConfigWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo;
            auto successFn = Callback<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRegulatoryConfigWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo;
            auto successFn = Callback<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRegulatoryConfigWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeLocationCapabilityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo;
            auto successFn = Callback<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLocationCapabilityWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo;
            auto successFn = Callback<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLocationCapabilityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeSupportsConcurrentConnectionWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralCommissioning::Attributes::SupportsConcurrentConnection::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSupportsConcurrentConnectionWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::SupportsConcurrentConnection::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSupportsConcurrentConnectionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GeneralCommissioning::Attributes::SupportsConcurrentConnection::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralCommissioning::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<GeneralCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<GeneralCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GeneralCommissioning::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GeneralCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralCommissioning::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<GeneralCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<GeneralCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GeneralCommissioning::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GeneralCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralCommissioning::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<GeneralCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<GeneralCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GeneralCommissioning::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GeneralCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralCommissioning::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GeneralCommissioning::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterNetworkCommissioning

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)scanNetworksWithParams:(MTRNetworkCommissioningClusterScanNetworksParams * _Nullable)params
                    completion:(void (^)(MTRNetworkCommissioningClusterScanNetworksResponseParams * _Nullable data,
                                   NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)addOrUpdateWiFiNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateWiFiNetworkParams *)params
                              completion:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data,
                                             NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)addOrUpdateThreadNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateThreadNetworkParams *)params
                                completion:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data,
                                               NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)removeNetworkWithParams:(MTRNetworkCommissioningClusterRemoveNetworkParams *)params
                     completion:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data,
                                    NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)connectNetworkWithParams:(MTRNetworkCommissioningClusterConnectNetworkParams *)params
                      completion:(void (^)(MTRNetworkCommissioningClusterConnectNetworkResponseParams * _Nullable data,
                                     NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)reorderNetworkWithParams:(MTRNetworkCommissioningClusterReorderNetworkParams *)params
                      completion:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data,
                                     NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)readAttributeMaxNetworksWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = NetworkCommissioning::Attributes::MaxNetworks::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxNetworksWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::MaxNetworks::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxNetworksWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = NetworkCommissioning::Attributes::MaxNetworks::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNetworksWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNetworkCommissioningNetworksListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = NetworkCommissioning::Attributes::Networks::TypeInfo;
            auto successFn = Callback<NetworkCommissioningNetworksListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNetworksWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::Networks::TypeInfo;
            auto successFn = Callback<NetworkCommissioningNetworksListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNetworksWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNetworkCommissioningNetworksListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = NetworkCommissioning::Attributes::Networks::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<NetworkCommissioningNetworksListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeScanMaxTimeSecondsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = NetworkCommissioning::Attributes::ScanMaxTimeSeconds::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeScanMaxTimeSecondsWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::ScanMaxTimeSeconds::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeScanMaxTimeSecondsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = NetworkCommissioning::Attributes::ScanMaxTimeSeconds::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeConnectMaxTimeSecondsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = NetworkCommissioning::Attributes::ConnectMaxTimeSeconds::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeConnectMaxTimeSecondsWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::ConnectMaxTimeSeconds::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeConnectMaxTimeSecondsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = NetworkCommissioning::Attributes::ConnectMaxTimeSeconds::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInterfaceEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInterfaceEnabledWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInterfaceEnabledWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInterfaceEnabledWithValue:(NSNumber * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                                     completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInterfaceEnabledWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInterfaceEnabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLastNetworkingStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(self.callbackQueue, self.device,
        completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = NetworkCommissioning::Attributes::LastNetworkingStatus::TypeInfo;
            auto successFn
                = Callback<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLastNetworkingStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::LastNetworkingStatus::TypeInfo;
            auto successFn
                = Callback<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLastNetworkingStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = NetworkCommissioning::Attributes::LastNetworkingStatus::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>::FromCancelable(
                        success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeLastNetworkIDWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = NetworkCommissioning::Attributes::LastNetworkID::TypeInfo;
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLastNetworkIDWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::LastNetworkID::TypeInfo;
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLastNetworkIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = NetworkCommissioning::Attributes::LastNetworkID::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLastConnectErrorValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = NetworkCommissioning::Attributes::LastConnectErrorValue::TypeInfo;
            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLastConnectErrorValueWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::LastConnectErrorValue::TypeInfo;
            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLastConnectErrorValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = NetworkCommissioning::Attributes::LastConnectErrorValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = NetworkCommissioning::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<NetworkCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<NetworkCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = NetworkCommissioning::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<NetworkCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = NetworkCommissioning::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<NetworkCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<NetworkCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = NetworkCommissioning::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<NetworkCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = NetworkCommissioning::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<NetworkCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<NetworkCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = NetworkCommissioning::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<NetworkCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterDiagnosticLogs

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)retrieveLogsRequestWithParams:(MTRDiagnosticLogsClusterRetrieveLogsRequestParams *)params
                           completion:(void (^)(MTRDiagnosticLogsClusterRetrieveLogsResponseParams * _Nullable data,
                                          NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DiagnosticLogs::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<DiagnosticLogsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DiagnosticLogs::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<DiagnosticLogsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = DiagnosticLogs::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<DiagnosticLogsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DiagnosticLogs::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<DiagnosticLogsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DiagnosticLogs::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<DiagnosticLogsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = DiagnosticLogs::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<DiagnosticLogsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<DiagnosticLogsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<DiagnosticLogsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<DiagnosticLogsAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DiagnosticLogs::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DiagnosticLogs::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DiagnosticLogs::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DiagnosticLogs::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DiagnosticLogs::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DiagnosticLogs::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterGeneralDiagnostics

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)testEventTriggerWithParams:(MTRGeneralDiagnosticsClusterTestEventTriggerParams *)params
                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeNetworkInterfacesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNetworkInterfacesWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNetworkInterfacesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeRebootCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRebootCountWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRebootCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUpTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeUpTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUpTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTotalOperationalHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTotalOperationalHoursWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTotalOperationalHoursWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBootReasonsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::BootReasons::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBootReasonsWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::BootReasons::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBootReasonsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GeneralDiagnostics::Attributes::BootReasons::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveHardwareFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActiveHardwareFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActiveHardwareFaultsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeActiveRadioFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActiveRadioFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActiveRadioFaultsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeActiveNetworkFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActiveNetworkFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActiveNetworkFaultsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeTestEventTriggersEnabledWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::TestEventTriggersEnabled::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTestEventTriggersEnabledWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::TestEventTriggersEnabled::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTestEventTriggersEnabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GeneralDiagnostics::Attributes::TestEventTriggersEnabled::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GeneralDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GeneralDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<GeneralDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GeneralDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GeneralDiagnostics::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterSoftwareDiagnostics

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)resetWatermarksWithCompletion:(MTRStatusCompletion)completion
{
    [self resetWatermarksWithParams:nil completion:completion];
}
- (void)resetWatermarksWithParams:(MTRSoftwareDiagnosticsClusterResetWatermarksParams * _Nullable)params
                       completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeThreadMetricsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo;
            auto successFn = Callback<SoftwareDiagnosticsThreadMetricsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeThreadMetricsWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo;
            auto successFn = Callback<SoftwareDiagnosticsThreadMetricsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeThreadMetricsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<SoftwareDiagnosticsThreadMetricsListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeCurrentHeapFreeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentHeapFreeWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentHeapFreeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentHeapUsedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentHeapUsedWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentHeapUsedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentHeapHighWatermarkWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentHeapHighWatermarkWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentHeapHighWatermarkWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = SoftwareDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = SoftwareDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = SoftwareDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = SoftwareDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<SoftwareDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<SoftwareDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<SoftwareDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterThreadNetworkDiagnostics

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)resetCountsWithCompletion:(MTRStatusCompletion)completion
{
    [self resetCountsWithParams:nil completion:completion];
}
- (void)resetCountsWithParams:(MTRThreadNetworkDiagnosticsClusterResetCountsParams * _Nullable)params
                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeChannelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeChannelWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeChannelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRoutingRoleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo;
            auto successFn = Callback<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRoutingRoleWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo;
            auto successFn = Callback<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRoutingRoleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeNetworkNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo;
            auto successFn = Callback<NullableCharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNetworkNameWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo;
            auto successFn = Callback<NullableCharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNetworkNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableCharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePanIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePanIdWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePanIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeExtendedPanIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeExtendedPanIdWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeExtendedPanIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeshLocalPrefixWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo;
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeshLocalPrefixWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo;
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeshLocalPrefixWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOverrunCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOverrunCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOverrunCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNeighborTableListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTableList::TypeInfo;
            auto successFn = Callback<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNeighborTableListWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTableList::TypeInfo;
            auto successFn = Callback<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNeighborTableListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTableList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeRouteTableListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTableList::TypeInfo;
            auto successFn = Callback<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRouteTableListWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTableList::TypeInfo;
            auto successFn = Callback<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRouteTableListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTableList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributePartitionIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePartitionIdWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePartitionIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWeightingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeWeightingWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWeightingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDataVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDataVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDataVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStableDataVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeStableDataVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeStableDataVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLeaderRouterIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLeaderRouterIdWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLeaderRouterIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDetachedRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDetachedRoleCountWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDetachedRoleCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeChildRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeChildRoleCountWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeChildRoleCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRouterRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRouterRoleCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRouterRoleCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLeaderRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLeaderRoleCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLeaderRoleCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttachAttemptCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttachAttemptCountWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttachAttemptCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePartitionIdChangeCountWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePartitionIdChangeCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePartitionIdChangeCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBetterPartitionAttachAttemptCountWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBetterPartitionAttachAttemptCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBetterPartitionAttachAttemptCountWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                   endpoint:(NSNumber *)endpoint
                                                                      queue:(dispatch_queue_t)queue
                                                                 completion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeParentChangeCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeParentChangeCountWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeParentChangeCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxTotalCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxTotalCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxTotalCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxUnicastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxUnicastCountWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxUnicastCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxBroadcastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxBroadcastCountWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxBroadcastCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxAckRequestedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxAckRequestedCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxAckRequestedCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxAckedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxAckedCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxAckedCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxNoAckRequestedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxNoAckRequestedCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxNoAckRequestedCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxDataCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxDataCountWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxDataCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxDataPollCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxDataPollCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxDataPollCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxBeaconCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxBeaconCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxBeaconCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxBeaconRequestCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxBeaconRequestCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxBeaconRequestCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxOtherCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxOtherCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxOtherCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxRetryCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxRetryCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxRetryCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxDirectMaxRetryExpiryCountWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxDirectMaxRetryExpiryCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxDirectMaxRetryExpiryCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                             endpoint:(NSNumber *)endpoint
                                                                queue:(dispatch_queue_t)queue
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxIndirectMaxRetryExpiryCountWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxIndirectMaxRetryExpiryCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxIndirectMaxRetryExpiryCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxErrCcaCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxErrCcaCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxErrCcaCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxErrAbortCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxErrAbortCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxErrAbortCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxErrBusyChannelCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxErrBusyChannelCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxErrBusyChannelCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxTotalCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxTotalCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxTotalCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxUnicastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxUnicastCountWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxUnicastCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxBroadcastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxBroadcastCountWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxBroadcastCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxDataCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxDataCountWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxDataCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxDataPollCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxDataPollCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxDataPollCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxBeaconCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxBeaconCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxBeaconCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxBeaconRequestCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxBeaconRequestCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxBeaconRequestCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxOtherCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxOtherCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxOtherCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxAddressFilteredCountWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxAddressFilteredCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxAddressFilteredCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxDestAddrFilteredCountWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxDestAddrFilteredCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxDestAddrFilteredCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxDuplicatedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxDuplicatedCountWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxDuplicatedCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxErrNoFrameCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxErrNoFrameCountWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxErrNoFrameCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxErrUnknownNeighborCountWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxErrUnknownNeighborCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxErrUnknownNeighborCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxErrInvalidSrcAddrCountWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxErrInvalidSrcAddrCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxErrInvalidSrcAddrCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxErrSecCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxErrSecCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxErrSecCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxErrFcsCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxErrFcsCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxErrFcsCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxErrOtherCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRxErrOtherCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRxErrOtherCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveTimestampWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActiveTimestampWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActiveTimestampWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePendingTimestampWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePendingTimestampWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePendingTimestampWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDelayWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDelayWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDelayWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSecurityPolicyWithCompletion:(void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value,
                                                      NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo;
            auto successFn = Callback<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSecurityPolicyWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value,
                                                       NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo;
            auto successFn = Callback<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSecurityPolicyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:
                                                  (void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value,
                                                      NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeChannelPage0MaskWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelPage0Mask::TypeInfo;
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeChannelPage0MaskWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelPage0Mask::TypeInfo;
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeChannelPage0MaskWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelPage0Mask::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOperationalDatasetComponentsWithCompletion:
    (void (^)(
        MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(self.callbackQueue, self.device,
        completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo;
            auto successFn
                = Callback<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)
    subscribeAttributeOperationalDatasetComponentsWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:
                                                   (void (^)(
                                                       MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value,
                                                       NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo;
            auto successFn
                = Callback<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)
    readAttributeOperationalDatasetComponentsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:
                                                            (void (^)(
                                                                MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value,
                                                                NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>::FromCancelable(
                        success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeActiveNetworkFaultsListWithCompletion:(void (^)(
                                                               NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo;
            auto successFn
                = Callback<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActiveNetworkFaultsListWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo;
            auto successFn
                = Callback<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActiveNetworkFaultsListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSArray * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ThreadNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ThreadNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterWiFiNetworkDiagnostics

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)resetCountsWithCompletion:(MTRStatusCompletion)completion
{
    [self resetCountsWithParams:nil completion:completion];
}
- (void)resetCountsWithParams:(MTRWiFiNetworkDiagnosticsClusterResetCountsParams * _Nullable)params
                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeBssidWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo;
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBssidWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo;
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBssidWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSecurityTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo;
            auto successFn = Callback<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSecurityTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo;
            auto successFn = Callback<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSecurityTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeWiFiVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;
            auto successFn
                = Callback<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeWiFiVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;
            auto successFn
                = Callback<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWiFiVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeChannelNumberWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeChannelNumberWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeChannelNumberWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRssiWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo;
            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRssiWithParams:(MTRSubscribeParams * _Nonnull)params
                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo;
            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRssiWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBeaconLostCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBeaconLostCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBeaconLostCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBeaconRxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBeaconRxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBeaconRxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePacketMulticastRxCountWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePacketMulticastRxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePacketMulticastRxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePacketMulticastTxCountWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePacketMulticastTxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePacketMulticastTxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePacketUnicastRxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePacketUnicastRxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePacketUnicastRxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePacketUnicastTxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePacketUnicastTxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePacketUnicastTxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentMaxRateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentMaxRateWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentMaxRateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOverrunCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOverrunCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOverrunCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = WiFiNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = WiFiNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterEthernetNetworkDiagnostics

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)resetCountsWithCompletion:(MTRStatusCompletion)completion
{
    [self resetCountsWithParams:nil completion:completion];
}
- (void)resetCountsWithParams:(MTREthernetNetworkDiagnosticsClusterResetCountsParams * _Nullable)params
                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributePHYRateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;
            auto successFn
                = Callback<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePHYRateWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;
            auto successFn
                = Callback<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePHYRateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFullDuplexWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo;
            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFullDuplexWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo;
            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFullDuplexWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePacketRxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePacketRxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePacketRxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePacketTxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePacketTxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePacketTxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxErrCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTxErrCountWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTxErrCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCollisionCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCollisionCountWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCollisionCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOverrunCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOverrunCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOverrunCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCarrierDetectWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo;
            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCarrierDetectWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo;
            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCarrierDetectWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTimeSinceResetWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTimeSinceResetWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTimeSinceResetWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = EthernetNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = EthernetNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBridgedDeviceBasic

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeVendorNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::VendorName::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeVendorNameWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::VendorName::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeVendorNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::VendorName::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeVendorIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::VendorID::TypeInfo;
            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeVendorIDWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRVendorIdAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::VendorID::TypeInfo;
            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeVendorIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::VendorID::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductName::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeProductNameWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductName::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeProductNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductName::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNodeLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::NodeLabel::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNodeLabelWithValue:(NSString * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value
                                  params:(MTRWriteParams * _Nullable)params
                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::NodeLabel::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNodeLabelWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::NodeLabel::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNodeLabelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::NodeLabel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeHardwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersion::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeHardwareVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersion::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeHardwareVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersion::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeHardwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersionString::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeHardwareVersionStringWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersionString::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeHardwareVersionStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersionString::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSoftwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersion::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSoftwareVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersion::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSoftwareVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersion::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSoftwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersionString::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSoftwareVersionStringWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersionString::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSoftwareVersionStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersionString::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeManufacturingDateWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::ManufacturingDate::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeManufacturingDateWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::ManufacturingDate::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeManufacturingDateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::ManufacturingDate::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePartNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::PartNumber::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePartNumberWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::PartNumber::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePartNumberWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::PartNumber::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductURLWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductURL::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeProductURLWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductURL::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeProductURLWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductURL::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductLabel::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeProductLabelWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductLabel::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeProductLabelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductLabel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSerialNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::SerialNumber::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSerialNumberWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::SerialNumber::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSerialNumberWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::SerialNumber::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReachableWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::Reachable::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeReachableWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::Reachable::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeReachableWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::Reachable::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUniqueIDWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::UniqueID::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeUniqueIDWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::UniqueID::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUniqueIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::UniqueID::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = BridgedDeviceBasic::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = BridgedDeviceBasic::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BridgedDeviceBasicAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BridgedDeviceBasicAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = BridgedDeviceBasic::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<BridgedDeviceBasicAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BridgedDeviceBasic::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BridgedDeviceBasic::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterSwitch

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeNumberOfPositionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNumberOfPositionsWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNumberOfPositionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentPositionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentPositionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentPositionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMultiPressMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMultiPressMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMultiPressMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSwitchGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Switch::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<SwitchGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<SwitchGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSwitchGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Switch::Attributes::GeneratedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<SwitchGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSwitchAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Switch::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<SwitchAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<SwitchAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSwitchAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Switch::Attributes::AcceptedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<SwitchAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSwitchAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Switch::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<SwitchAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<SwitchAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRSwitchAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Switch::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<SwitchAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterAdministratorCommissioning

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)openCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterOpenCommissioningWindowParams *)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)openBasicCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterOpenBasicCommissioningWindowParams *)params
                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)revokeCommissioningWithCompletion:(MTRStatusCompletion)completion
{
    [self revokeCommissioningWithParams:nil completion:completion];
}
- (void)revokeCommissioningWithParams:(MTRAdministratorCommissioningClusterRevokeCommissioningParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeWindowStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(self.callbackQueue, self.device,
        completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;
            auto successFn
                = Callback<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeWindowStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;
            auto successFn
                = Callback<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWindowStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>::FromCancelable(
                        success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAdminFabricIndexWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAdminFabricIndexWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAdminFabricIndexWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAdminVendorIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAdminVendorIdWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAdminVendorIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AdministratorCommissioning::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<AdministratorCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<AdministratorCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = AdministratorCommissioning::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<AdministratorCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AdministratorCommissioning::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<AdministratorCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<AdministratorCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = AdministratorCommissioning::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<AdministratorCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<AdministratorCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<AdministratorCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<AdministratorCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AdministratorCommissioning::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AdministratorCommissioning::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterOperationalCredentials

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)attestationRequestWithParams:(MTROperationalCredentialsClusterAttestationRequestParams *)params
                          completion:(void (^)(MTROperationalCredentialsClusterAttestationResponseParams * _Nullable data,
                                         NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsClusterAttestationResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)certificateChainRequestWithParams:(MTROperationalCredentialsClusterCertificateChainRequestParams *)params
                               completion:(void (^)(MTROperationalCredentialsClusterCertificateChainResponseParams * _Nullable data,
                                              NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)CSRRequestWithParams:(MTROperationalCredentialsClusterCSRRequestParams *)params
                  completion:(void (^)(MTROperationalCredentialsClusterCSRResponseParams * _Nullable data,
                                 NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsClusterCSRResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)addNOCWithParams:(MTROperationalCredentialsClusterAddNOCParams *)params
              completion:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data,
                             NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)updateNOCWithParams:(MTROperationalCredentialsClusterUpdateNOCParams *)params
                 completion:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data,
                                NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)updateFabricLabelWithParams:(MTROperationalCredentialsClusterUpdateFabricLabelParams *)params
                         completion:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data,
                                        NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)removeFabricWithParams:(MTROperationalCredentialsClusterRemoveFabricParams *)params
                    completion:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data,
                                   NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)addTrustedRootCertificateWithParams:(MTROperationalCredentialsClusterAddTrustedRootCertificateParams *)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeNOCsWithParams:(MTRReadParams * _Nullable)params
                         completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{ // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsNOCsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OperationalCredentials::Attributes::NOCs::TypeInfo;
            auto successFn = Callback<OperationalCredentialsNOCsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(
                successFn->mContext, successFn->mCall, failureFn->mCall, params.fabricFiltered);
        });
}

- (void)subscribeAttributeNOCsWithParams:(MTRSubscribeParams * _Nonnull)params
                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::NOCs::TypeInfo;
            auto successFn = Callback<OperationalCredentialsNOCsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNOCsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROperationalCredentialsNOCsListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OperationalCredentials::Attributes::NOCs::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<OperationalCredentialsNOCsListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFabricsWithParams:(MTRReadParams * _Nullable)params
                            completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{ // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsFabricsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OperationalCredentials::Attributes::Fabrics::TypeInfo;
            auto successFn = Callback<OperationalCredentialsFabricsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(
                successFn->mContext, successFn->mCall, failureFn->mCall, params.fabricFiltered);
        });
}

- (void)subscribeAttributeFabricsWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::Fabrics::TypeInfo;
            auto successFn = Callback<OperationalCredentialsFabricsListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFabricsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROperationalCredentialsFabricsListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OperationalCredentials::Attributes::Fabrics::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<OperationalCredentialsFabricsListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeSupportedFabricsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSupportedFabricsWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSupportedFabricsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCommissionedFabricsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCommissionedFabricsWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCommissionedFabricsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTrustedRootCertificatesWithCompletion:(void (^)(
                                                               NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo;
            auto successFn = Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTrustedRootCertificatesWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo;
            auto successFn = Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTrustedRootCertificatesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSArray * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeCurrentFabricIndexWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentFabricIndexWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentFabricIndexWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OperationalCredentials::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<OperationalCredentialsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<OperationalCredentialsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OperationalCredentials::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<OperationalCredentialsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OperationalCredentials::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<OperationalCredentialsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<OperationalCredentialsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OperationalCredentials::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<OperationalCredentialsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROperationalCredentialsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OperationalCredentials::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<OperationalCredentialsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<OperationalCredentialsAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROperationalCredentialsAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OperationalCredentials::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<OperationalCredentialsAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OperationalCredentials::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OperationalCredentials::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterGroupKeyManagement

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)keySetWriteWithParams:(MTRGroupKeyManagementClusterKeySetWriteParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)keySetReadWithParams:(MTRGroupKeyManagementClusterKeySetReadParams *)params
                  completion:(void (^)(MTRGroupKeyManagementClusterKeySetReadResponseParams * _Nullable data,
                                 NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)keySetRemoveWithParams:(MTRGroupKeyManagementClusterKeySetRemoveParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)keySetReadAllIndicesWithParams:(MTRGroupKeyManagementClusterKeySetReadAllIndicesParams *)params
                            completion:(void (^)(MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseParams * _Nullable data,
                                           NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)readAttributeGroupKeyMapWithParams:(MTRReadParams * _Nullable)params
                                completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{ // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
            auto successFn = Callback<GroupKeyManagementGroupKeyMapListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(
                successFn->mContext, successFn->mCall, failureFn->mCall, params.fabricFiltered);
        });
}

- (void)writeAttributeGroupKeyMapWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeGroupKeyMapWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeGroupKeyMapWithValue:(NSArray * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.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 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[MTRGroupKeyManagementClusterGroupKeyMapStruct class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (MTRGroupKeyManagementClusterGroupKeyMapStruct *) value[i_0];
                        listHolder_0->mList[i_0].groupId = element_0.groupId.unsignedShortValue;
                        listHolder_0->mList[i_0].groupKeySetID = element_0.groupKeySetID.unsignedShortValue;
                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeGroupKeyMapWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
            auto successFn = Callback<GroupKeyManagementGroupKeyMapListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGroupKeyMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GroupKeyManagementGroupKeyMapListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGroupTableWithParams:(MTRReadParams * _Nullable)params
                               completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{ // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GroupKeyManagement::Attributes::GroupTable::TypeInfo;
            auto successFn = Callback<GroupKeyManagementGroupTableListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(
                successFn->mContext, successFn->mCall, failureFn->mCall, params.fabricFiltered);
        });
}

- (void)subscribeAttributeGroupTableWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::GroupTable::TypeInfo;
            auto successFn = Callback<GroupKeyManagementGroupTableListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGroupTableWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GroupKeyManagement::Attributes::GroupTable::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GroupKeyManagementGroupTableListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeMaxGroupsPerFabricWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GroupKeyManagement::Attributes::MaxGroupsPerFabric::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxGroupsPerFabricWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::MaxGroupsPerFabric::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxGroupsPerFabricWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GroupKeyManagement::Attributes::MaxGroupsPerFabric::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxGroupKeysPerFabricWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GroupKeyManagement::Attributes::MaxGroupKeysPerFabric::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxGroupKeysPerFabricWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::MaxGroupKeysPerFabric::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxGroupKeysPerFabricWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GroupKeyManagement::Attributes::MaxGroupKeysPerFabric::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GroupKeyManagement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<GroupKeyManagementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<GroupKeyManagementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GroupKeyManagement::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GroupKeyManagementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GroupKeyManagement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<GroupKeyManagementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<GroupKeyManagementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GroupKeyManagement::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GroupKeyManagementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GroupKeyManagement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<GroupKeyManagementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<GroupKeyManagementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = GroupKeyManagement::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<GroupKeyManagementAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GroupKeyManagement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GroupKeyManagement::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterFixedLabel

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeLabelListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFixedLabelLabelListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo;
            auto successFn = Callback<FixedLabelLabelListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLabelListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo;
            auto successFn = Callback<FixedLabelLabelListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLabelListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFixedLabelLabelListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<FixedLabelLabelListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FixedLabel::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<FixedLabelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FixedLabel::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<FixedLabelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = FixedLabel::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<FixedLabelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FixedLabel::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<FixedLabelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FixedLabel::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<FixedLabelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = FixedLabel::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<FixedLabelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFixedLabelAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FixedLabel::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<FixedLabelAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FixedLabel::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<FixedLabelAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFixedLabelAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FixedLabel::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<FixedLabelAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FixedLabel::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FixedLabel::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FixedLabel::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterUserLabel

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeLabelListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUserLabelLabelListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
            auto successFn = Callback<UserLabelLabelListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLabelListWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLabelListWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeLabelListWithValue:(NSArray * _Nonnull)value
                                  params:(MTRWriteParams * _Nullable)params
                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.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 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[MTRUserLabelClusterLabelStruct class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (MTRUserLabelClusterLabelStruct *) value[i_0];
                        listHolder_0->mList[i_0].label = [self asCharSpan:element_0.label];
                        listHolder_0->mList[i_0].value = [self asCharSpan:element_0.value];
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLabelListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
            auto successFn = Callback<UserLabelLabelListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLabelListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUserLabelLabelListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<UserLabelLabelListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = UserLabel::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<UserLabelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UserLabel::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<UserLabelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = UserLabel::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<UserLabelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = UserLabel::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<UserLabelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UserLabel::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<UserLabelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = UserLabel::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<UserLabelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUserLabelAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = UserLabel::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<UserLabelAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UserLabel::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<UserLabelAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRUserLabelAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = UserLabel::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<UserLabelAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = UserLabel::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UserLabel::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = UserLabel::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = UserLabel::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UserLabel::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = UserLabel::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBooleanState

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeStateValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeStateValueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeStateValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BooleanState::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BooleanStateGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BooleanState::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BooleanStateGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = BooleanState::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<BooleanStateGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BooleanState::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BooleanStateAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BooleanState::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BooleanStateAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = BooleanState::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<BooleanStateAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanStateAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BooleanState::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BooleanStateAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BooleanState::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BooleanStateAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanStateAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BooleanState::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanStateAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BooleanState::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BooleanState::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BooleanState::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterModeSelect

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)changeToModeWithParams:(MTRModeSelectClusterChangeToModeParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeDescriptionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ModeSelect::Attributes::Description::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDescriptionWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::Description::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDescriptionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ModeSelect::Attributes::Description::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStandardNamespaceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ModeSelect::Attributes::StandardNamespace::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeStandardNamespaceWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::StandardNamespace::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeStandardNamespaceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ModeSelect::Attributes::StandardNamespace::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSupportedModesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRModeSelectSupportedModesListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo;
            auto successFn = Callback<ModeSelectSupportedModesListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSupportedModesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo;
            auto successFn = Callback<ModeSelectSupportedModesListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSupportedModesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRModeSelectSupportedModesListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ModeSelectSupportedModesListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentModeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStartUpModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeStartUpModeWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeStartUpModeWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeStartUpModeWithValue:(NSNumber * _Nullable)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeStartUpModeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeStartUpModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOnModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOnModeWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOnModeWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeOnModeWithValue:(NSNumber * _Nullable)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOnModeWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOnModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ModeSelect::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ModeSelectGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ModeSelectGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ModeSelect::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ModeSelectGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ModeSelect::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ModeSelectAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ModeSelectAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ModeSelect::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ModeSelectAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRModeSelectAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ModeSelect::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ModeSelectAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ModeSelectAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRModeSelectAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ModeSelect::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ModeSelectAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ModeSelect::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ModeSelect::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterDoorLock

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)lockDoorWithParams:(MTRDoorLockClusterLockDoorParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)unlockDoorWithParams:(MTRDoorLockClusterUnlockDoorParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)unlockWithTimeoutWithParams:(MTRDoorLockClusterUnlockWithTimeoutParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)setWeekDayScheduleWithParams:(MTRDoorLockClusterSetWeekDayScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)getWeekDayScheduleWithParams:(MTRDoorLockClusterGetWeekDayScheduleParams *)params
                          completion:(void (^)(MTRDoorLockClusterGetWeekDayScheduleResponseParams * _Nullable data,
                                         NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)clearWeekDayScheduleWithParams:(MTRDoorLockClusterClearWeekDayScheduleParams *)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)setYearDayScheduleWithParams:(MTRDoorLockClusterSetYearDayScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)getYearDayScheduleWithParams:(MTRDoorLockClusterGetYearDayScheduleParams *)params
                          completion:(void (^)(MTRDoorLockClusterGetYearDayScheduleResponseParams * _Nullable data,
                                         NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)clearYearDayScheduleWithParams:(MTRDoorLockClusterClearYearDayScheduleParams *)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)setHolidayScheduleWithParams:(MTRDoorLockClusterSetHolidayScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)getHolidayScheduleWithParams:(MTRDoorLockClusterGetHolidayScheduleParams *)params
                          completion:(void (^)(MTRDoorLockClusterGetHolidayScheduleResponseParams * _Nullable data,
                                         NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)clearHolidayScheduleWithParams:(MTRDoorLockClusterClearHolidayScheduleParams *)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)setUserWithParams:(MTRDoorLockClusterSetUserParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)getUserWithParams:(MTRDoorLockClusterGetUserParams *)params
               completion:(void (^)(MTRDoorLockClusterGetUserResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockClusterGetUserResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)clearUserWithParams:(MTRDoorLockClusterClearUserParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)setCredentialWithParams:(MTRDoorLockClusterSetCredentialParams *)params
                     completion:(void (^)(MTRDoorLockClusterSetCredentialResponseParams * _Nullable data,
                                    NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockClusterSetCredentialResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)getCredentialStatusWithParams:(MTRDoorLockClusterGetCredentialStatusParams *)params
                           completion:(void (^)(MTRDoorLockClusterGetCredentialStatusResponseParams * _Nullable data,
                                          NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)clearCredentialWithParams:(MTRDoorLockClusterClearCredentialParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeLockStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::LockState::TypeInfo;
            auto successFn = Callback<NullableDoorLockClusterDlLockStateAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLockStateWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::LockState::TypeInfo;
            auto successFn = Callback<NullableDoorLockClusterDlLockStateAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLockStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = DoorLock::Attributes::LockState::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<NullableDoorLockClusterDlLockStateAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeLockTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::LockType::TypeInfo;
            auto successFn = Callback<DoorLockClusterDlLockTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLockTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::LockType::TypeInfo;
            auto successFn = Callback<DoorLockClusterDlLockTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLockTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::LockType::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<DoorLockClusterDlLockTypeAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActuatorEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActuatorEnabledWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActuatorEnabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDoorStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::DoorState::TypeInfo;
            auto successFn = Callback<NullableDoorLockClusterDlDoorStateAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDoorStateWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::DoorState::TypeInfo;
            auto successFn = Callback<NullableDoorLockClusterDlDoorStateAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDoorStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = DoorLock::Attributes::DoorState::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<NullableDoorLockClusterDlDoorStateAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeDoorOpenEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDoorOpenEventsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeDoorOpenEventsWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeDoorOpenEventsWithValue:(NSNumber * _Nonnull)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeDoorOpenEventsWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDoorOpenEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDoorClosedEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDoorClosedEventsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeDoorClosedEventsWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeDoorClosedEventsWithValue:(NSNumber * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                                     completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeDoorClosedEventsWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDoorClosedEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOpenPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOpenPeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOpenPeriodWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeOpenPeriodWithValue:(NSNumber * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOpenPeriodWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOpenPeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfTotalUsersSupportedWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::NumberOfTotalUsersSupported::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNumberOfTotalUsersSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfTotalUsersSupported::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNumberOfTotalUsersSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                             endpoint:(NSNumber *)endpoint
                                                                queue:(dispatch_queue_t)queue
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::NumberOfTotalUsersSupported::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfPINUsersSupportedWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::NumberOfPINUsersSupported::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNumberOfPINUsersSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfPINUsersSupported::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNumberOfPINUsersSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::NumberOfPINUsersSupported::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfRFIDUsersSupportedWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::NumberOfRFIDUsersSupported::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNumberOfRFIDUsersSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfRFIDUsersSupported::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNumberOfRFIDUsersSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::NumberOfRFIDUsersSupported::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNumberOfWeekDaySchedulesSupportedPerUserWithParams:(MTRSubscribeParams * _Nonnull)params
                                                     subscriptionEstablished:
                                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                               reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                          endpoint:(NSNumber *)endpoint
                                                                             queue:(dispatch_queue_t)queue
                                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                                       NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNumberOfYearDaySchedulesSupportedPerUserWithParams:(MTRSubscribeParams * _Nonnull)params
                                                     subscriptionEstablished:
                                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                               reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                          endpoint:(NSNumber *)endpoint
                                                                             queue:(dispatch_queue_t)queue
                                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                                       NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfHolidaySchedulesSupportedWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::NumberOfHolidaySchedulesSupported::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNumberOfHolidaySchedulesSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfHolidaySchedulesSupported::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNumberOfHolidaySchedulesSupportedWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                   endpoint:(NSNumber *)endpoint
                                                                      queue:(dispatch_queue_t)queue
                                                                 completion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::NumberOfHolidaySchedulesSupported::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxPINCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::MaxPINCodeLength::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxPINCodeLengthWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::MaxPINCodeLength::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxPINCodeLengthWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::MaxPINCodeLength::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinPINCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::MinPINCodeLength::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinPINCodeLengthWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::MinPINCodeLength::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinPINCodeLengthWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::MinPINCodeLength::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxRFIDCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::MaxRFIDCodeLength::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxRFIDCodeLengthWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::MaxRFIDCodeLength::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxRFIDCodeLengthWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::MaxRFIDCodeLength::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinRFIDCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::MinRFIDCodeLength::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinRFIDCodeLengthWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::MinRFIDCodeLength::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinRFIDCodeLengthWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::MinRFIDCodeLength::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCredentialRulesSupportWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;
            auto successFn = Callback<DoorLockCredentialRulesSupportAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCredentialRulesSupportWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;
            auto successFn = Callback<DoorLockCredentialRulesSupportAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCredentialRulesSupportWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<DoorLockCredentialRulesSupportAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfCredentialsSupportedPerUserWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNumberOfCredentialsSupportedPerUserWithParams:(MTRSubscribeParams * _Nonnull)params
                                                subscriptionEstablished:
                                                    (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                          reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNumberOfCredentialsSupportedPerUserWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                     endpoint:(NSNumber *)endpoint
                                                                        queue:(dispatch_queue_t)queue
                                                                   completion:(void (^)(NSNumber * _Nullable value,
                                                                                  NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLanguageWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLanguageWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLanguageWithValue:(NSString * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeLanguageWithValue:(NSString * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLanguageWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLanguageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLEDSettingsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLEDSettingsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLEDSettingsWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeLEDSettingsWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLEDSettingsWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLEDSettingsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAutoRelockTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAutoRelockTimeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeAutoRelockTimeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeAutoRelockTimeWithValue:(NSNumber * _Nonnull)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeAutoRelockTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAutoRelockTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSoundVolumeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSoundVolumeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeSoundVolumeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeSoundVolumeWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeSoundVolumeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSoundVolumeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOperatingModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
            auto successFn = Callback<DoorLockClusterDlOperatingModeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOperatingModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOperatingModeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeOperatingModeWithValue:(NSNumber * _Nonnull)value
                                      params:(MTRWriteParams * _Nullable)params
                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOperatingModeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
            auto successFn = Callback<DoorLockClusterDlOperatingModeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOperatingModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<DoorLockClusterDlOperatingModeAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSupportedOperatingModesWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;
            auto successFn = Callback<DoorLockSupportedOperatingModesAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSupportedOperatingModesWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;
            auto successFn = Callback<DoorLockSupportedOperatingModesAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSupportedOperatingModesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<DoorLockSupportedOperatingModesAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDefaultConfigurationRegisterWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::DefaultConfigurationRegister::TypeInfo;
            auto successFn = Callback<DoorLockDefaultConfigurationRegisterAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDefaultConfigurationRegisterWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::DefaultConfigurationRegister::TypeInfo;
            auto successFn = Callback<DoorLockDefaultConfigurationRegisterAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDefaultConfigurationRegisterWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = DoorLock::Attributes::DefaultConfigurationRegister::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<DoorLockDefaultConfigurationRegisterAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeEnableLocalProgrammingWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEnableLocalProgrammingWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeEnableLocalProgrammingWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeEnableLocalProgrammingWithValue:(NSNumber * _Nonnull)value
                                               params:(MTRWriteParams * _Nullable)params
                                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeEnableLocalProgrammingWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEnableLocalProgrammingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnableOneTouchLockingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEnableOneTouchLockingWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeEnableOneTouchLockingWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeEnableOneTouchLockingWithValue:(NSNumber * _Nonnull)value
                                              params:(MTRWriteParams * _Nullable)params
                                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeEnableOneTouchLockingWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEnableOneTouchLockingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnableInsideStatusLEDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEnableInsideStatusLEDWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeEnableInsideStatusLEDWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeEnableInsideStatusLEDWithValue:(NSNumber * _Nonnull)value
                                              params:(MTRWriteParams * _Nullable)params
                                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeEnableInsideStatusLEDWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEnableInsideStatusLEDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnablePrivacyModeButtonWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEnablePrivacyModeButtonWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeEnablePrivacyModeButtonWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeEnablePrivacyModeButtonWithValue:(NSNumber * _Nonnull)value
                                                params:(MTRWriteParams * _Nullable)params
                                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeEnablePrivacyModeButtonWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEnablePrivacyModeButtonWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLocalProgrammingFeaturesWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
            auto successFn = Callback<DoorLockLocalProgrammingFeaturesAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLocalProgrammingFeaturesWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLocalProgrammingFeaturesWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeLocalProgrammingFeaturesWithValue:(NSNumber * _Nonnull)value
                                                 params:(MTRWriteParams * _Nullable)params
                                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLocalProgrammingFeaturesWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
            auto successFn = Callback<DoorLockLocalProgrammingFeaturesAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLocalProgrammingFeaturesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<DoorLockLocalProgrammingFeaturesAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeWrongCodeEntryLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWrongCodeEntryLimitWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeWrongCodeEntryLimitWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeWrongCodeEntryLimitWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeWrongCodeEntryLimitWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWrongCodeEntryLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUserCodeTemporaryDisableTimeWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUserCodeTemporaryDisableTimeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeUserCodeTemporaryDisableTimeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeUserCodeTemporaryDisableTimeWithValue:(NSNumber * _Nonnull)value
                                                     params:(MTRWriteParams * _Nullable)params
                                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeUserCodeTemporaryDisableTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUserCodeTemporaryDisableTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSendPINOverTheAirWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSendPINOverTheAirWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeSendPINOverTheAirWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeSendPINOverTheAirWithValue:(NSNumber * _Nonnull)value
                                          params:(MTRWriteParams * _Nullable)params
                                      completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeSendPINOverTheAirWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSendPINOverTheAirWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRequirePINforRemoteOperationWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRequirePINforRemoteOperationWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeRequirePINforRemoteOperationWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeRequirePINforRemoteOperationWithValue:(NSNumber * _Nonnull)value
                                                     params:(MTRWriteParams * _Nullable)params
                                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeRequirePINforRemoteOperationWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRequirePINforRemoteOperationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeExpiringUserTimeoutWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeExpiringUserTimeoutWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeExpiringUserTimeoutWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeExpiringUserTimeoutWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeExpiringUserTimeoutWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeExpiringUserTimeoutWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<DoorLockGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<DoorLockGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = DoorLock::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<DoorLockGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<DoorLockAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<DoorLockAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::AcceptedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<DoorLockAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoorLockAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<DoorLockAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<DoorLockAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoorLockAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<DoorLockAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterWindowCovering

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)upOrOpenWithCompletion:(MTRStatusCompletion)completion
{
    [self upOrOpenWithParams:nil completion:completion];
}
- (void)upOrOpenWithParams:(MTRWindowCoveringClusterUpOrOpenParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)downOrCloseWithCompletion:(MTRStatusCompletion)completion
{
    [self downOrCloseWithParams:nil completion:completion];
}
- (void)downOrCloseWithParams:(MTRWindowCoveringClusterDownOrCloseParams * _Nullable)params
                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)stopMotionWithCompletion:(MTRStatusCompletion)completion
{
    [self stopMotionWithParams:nil completion:completion];
}
- (void)stopMotionWithParams:(MTRWindowCoveringClusterStopMotionParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)goToLiftValueWithParams:(MTRWindowCoveringClusterGoToLiftValueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)goToLiftPercentageWithParams:(MTRWindowCoveringClusterGoToLiftPercentageParams *)params
                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)goToTiltValueWithParams:(MTRWindowCoveringClusterGoToTiltValueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)goToTiltPercentageWithParams:(MTRWindowCoveringClusterGoToTiltPercentageParams *)params
                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringClusterTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::Type::TypeInfo;
            auto successFn = Callback<WindowCoveringClusterTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::Type::TypeInfo;
            auto successFn = Callback<WindowCoveringClusterTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringClusterTypeAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::Type::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<WindowCoveringClusterTypeAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhysicalClosedLimitLiftWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitLift::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePhysicalClosedLimitLiftWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitLift::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePhysicalClosedLimitLiftWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitLift::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhysicalClosedLimitTiltWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitTilt::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePhysicalClosedLimitTiltWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitTilt::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePhysicalClosedLimitTiltWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitTilt::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentPositionLiftWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentPositionLiftWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentPositionLiftWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentPositionTiltWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentPositionTiltWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentPositionTiltWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfActuationsLiftWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::NumberOfActuationsLift::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNumberOfActuationsLiftWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::NumberOfActuationsLift::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNumberOfActuationsLiftWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::NumberOfActuationsLift::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfActuationsTiltWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::NumberOfActuationsTilt::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNumberOfActuationsTiltWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::NumberOfActuationsTilt::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNumberOfActuationsTiltWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::NumberOfActuationsTilt::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeConfigStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringConfigStatusAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo;
            auto successFn = Callback<WindowCoveringConfigStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeConfigStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo;
            auto successFn = Callback<WindowCoveringConfigStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeConfigStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringConfigStatusAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<WindowCoveringConfigStatusAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentPositionLiftPercentageWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentPositionLiftPercentageWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentPositionLiftPercentageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentPositionTiltPercentageWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentPositionTiltPercentageWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentPositionTiltPercentageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOperationalStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringOperationalStatusAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;
            auto successFn = Callback<WindowCoveringOperationalStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOperationalStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;
            auto successFn = Callback<WindowCoveringOperationalStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOperationalStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringOperationalStatusAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<WindowCoveringOperationalStatusAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTargetPositionLiftPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTargetPositionLiftPercent100thsWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTargetPositionLiftPercent100thsWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTargetPositionTiltPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTargetPositionTiltPercent100thsWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTargetPositionTiltPercent100thsWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEndProductTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo;
            auto successFn = Callback<WindowCoveringClusterEndProductTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeEndProductTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo;
            auto successFn = Callback<WindowCoveringClusterEndProductTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEndProductTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<WindowCoveringClusterEndProductTypeAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeCurrentPositionLiftPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentPositionLiftPercent100thsWithParams:(MTRSubscribeParams * _Nonnull)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentPositionLiftPercent100thsWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentPositionTiltPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentPositionTiltPercent100thsWithParams:(MTRSubscribeParams * _Nonnull)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentPositionTiltPercent100thsWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstalledOpenLimitLiftWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeInstalledOpenLimitLiftWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInstalledOpenLimitLiftWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstalledClosedLimitLiftWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeInstalledClosedLimitLiftWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInstalledClosedLimitLiftWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstalledOpenLimitTiltWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeInstalledOpenLimitTiltWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInstalledOpenLimitTiltWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstalledClosedLimitTiltWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeInstalledClosedLimitTiltWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInstalledClosedLimitTiltWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringModeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
            auto successFn = Callback<WindowCoveringModeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeModeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeModeWithValue:(NSNumber * _Nonnull)value
                             params:(MTRWriteParams * _Nullable)params
                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeModeWithParams:(MTRSubscribeParams * _Nonnull)params
                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWindowCoveringModeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
            auto successFn = Callback<WindowCoveringModeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringModeAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<WindowCoveringModeAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSafetyStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringSafetyStatusAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo;
            auto successFn = Callback<WindowCoveringSafetyStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSafetyStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo;
            auto successFn = Callback<WindowCoveringSafetyStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSafetyStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringSafetyStatusAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<WindowCoveringSafetyStatusAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<WindowCoveringGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<WindowCoveringGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = WindowCovering::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<WindowCoveringGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<WindowCoveringAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<WindowCoveringAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = WindowCovering::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<WindowCoveringAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<WindowCoveringAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<WindowCoveringAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWindowCoveringAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<WindowCoveringAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBarrierControl

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)barrierControlGoToPercentWithParams:(MTRBarrierControlClusterBarrierControlGoToPercentParams *)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)barrierControlStopWithCompletion:(MTRStatusCompletion)completion
{
    [self barrierControlStopWithParams:nil completion:completion];
}
- (void)barrierControlStopWithParams:(MTRBarrierControlClusterBarrierControlStopParams * _Nullable)params
                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeBarrierMovingStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBarrierMovingStateWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBarrierMovingStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierSafetyStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBarrierSafetyStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBarrierSafetyStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierCapabilitiesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBarrierCapabilitiesWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBarrierCapabilitiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierOpenEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBarrierOpenEventsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBarrierOpenEventsWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeBarrierOpenEventsWithValue:(NSNumber * _Nonnull)value
                                          params:(MTRWriteParams * _Nullable)params
                                      completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBarrierOpenEventsWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBarrierOpenEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierCloseEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBarrierCloseEventsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBarrierCloseEventsWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeBarrierCloseEventsWithValue:(NSNumber * _Nonnull)value
                                           params:(MTRWriteParams * _Nullable)params
                                       completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBarrierCloseEventsWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBarrierCloseEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierCommandOpenEventsWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBarrierCommandOpenEventsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBarrierCommandOpenEventsWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeBarrierCommandOpenEventsWithValue:(NSNumber * _Nonnull)value
                                                 params:(MTRWriteParams * _Nullable)params
                                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBarrierCommandOpenEventsWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBarrierCommandOpenEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierCommandCloseEventsWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBarrierCommandCloseEventsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBarrierCommandCloseEventsWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeBarrierCommandCloseEventsWithValue:(NSNumber * _Nonnull)value
                                                  params:(MTRWriteParams * _Nullable)params
                                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBarrierCommandCloseEventsWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBarrierCommandCloseEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierOpenPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBarrierOpenPeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBarrierOpenPeriodWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeBarrierOpenPeriodWithValue:(NSNumber * _Nonnull)value
                                          params:(MTRWriteParams * _Nullable)params
                                      completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBarrierOpenPeriodWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBarrierOpenPeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierClosePeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBarrierClosePeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBarrierClosePeriodWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeBarrierClosePeriodWithValue:(NSNumber * _Nonnull)value
                                           params:(MTRWriteParams * _Nullable)params
                                       completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBarrierClosePeriodWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBarrierClosePeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierPositionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBarrierPositionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBarrierPositionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BarrierControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BarrierControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = BarrierControl::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<BarrierControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BarrierControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BarrierControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = BarrierControl::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<BarrierControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBarrierControlAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BarrierControlAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BarrierControlAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBarrierControlAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BarrierControlAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BarrierControl::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterPumpConfigurationAndControl

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeMaxPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxPressureWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxPressureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxSpeedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxFlowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxFlowWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxFlowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinConstPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinConstPressureWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinConstPressureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxConstPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxConstPressureWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxConstPressureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinCompPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinCompPressureWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinCompPressureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxCompPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxCompPressureWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxCompPressureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinConstSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinConstSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinConstSpeedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxConstSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxConstSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxConstSpeedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinConstFlowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinConstFlowWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinConstFlowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxConstFlowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxConstFlowWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxConstFlowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinConstTempWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinConstTempWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinConstTempWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxConstTempWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxConstTempWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxConstTempWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePumpStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo;
            auto successFn = Callback<PumpConfigurationAndControlPumpStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePumpStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo;
            auto successFn = Callback<PumpConfigurationAndControlPumpStatusAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePumpStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PumpConfigurationAndControlPumpStatusAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeEffectiveOperationModeWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;
            auto successFn
                = Callback<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeEffectiveOperationModeWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;
            auto successFn
                = Callback<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEffectiveOperationModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeEffectiveControlModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo;
            auto successFn = Callback<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeEffectiveControlModeWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo;
            auto successFn = Callback<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEffectiveControlModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCapacityWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCapacityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSpeedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLifetimeRunningHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLifetimeRunningHoursWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLifetimeRunningHoursWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeLifetimeRunningHoursWithValue:(NSNumber * _Nullable)value
                                             params:(MTRWriteParams * _Nullable)params
                                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedIntValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLifetimeRunningHoursWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLifetimeRunningHoursWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePowerWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLifetimeEnergyConsumedWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLifetimeEnergyConsumedWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLifetimeEnergyConsumedWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeLifetimeEnergyConsumedWithValue:(NSNumber * _Nullable)value
                                               params:(MTRWriteParams * _Nullable)params
                                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedIntValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLifetimeEnergyConsumedWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLifetimeEnergyConsumedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOperationModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
            auto successFn
                = Callback<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOperationModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOperationModeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeOperationModeWithValue:(NSNumber * _Nonnull)value
                                      params:(MTRWriteParams * _Nullable)params
                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOperationModeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
            auto successFn
                = Callback<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOperationModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeControlModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
            auto successFn = Callback<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeControlModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeControlModeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeControlModeWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeControlModeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
            auto successFn = Callback<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeControlModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn
                = Callback<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn
                = Callback<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PumpConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<PumpConfigurationAndControlAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<PumpConfigurationAndControlAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PumpConfigurationAndControlAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterThermostat

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)setpointRaiseLowerWithParams:(MTRThermostatClusterSetpointRaiseLowerParams *)params
                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)setWeeklyScheduleWithParams:(MTRThermostatClusterSetWeeklyScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)getWeeklyScheduleWithParams:(MTRThermostatClusterGetWeeklyScheduleParams *)params
                         completion:(void (^)(MTRThermostatClusterGetWeeklyScheduleResponseParams * _Nullable data,
                                        NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)clearWeeklyScheduleWithCompletion:(MTRStatusCompletion)completion
{
    [self clearWeeklyScheduleWithParams:nil completion:completion];
}
- (void)clearWeeklyScheduleWithParams:(MTRThermostatClusterClearWeeklyScheduleParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeLocalTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLocalTemperatureWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLocalTemperatureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOutdoorTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::OutdoorTemperature::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOutdoorTemperatureWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::OutdoorTemperature::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOutdoorTemperatureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::OutdoorTemperature::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupancyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::Occupancy::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOccupancyWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::Occupancy::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOccupancyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::Occupancy::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAbsMinHeatSetpointLimitWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAbsMinHeatSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAbsMinHeatSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAbsMaxHeatSetpointLimitWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAbsMaxHeatSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAbsMaxHeatSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAbsMinCoolSetpointLimitWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAbsMinCoolSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAbsMinCoolSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAbsMaxCoolSetpointLimitWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAbsMaxCoolSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAbsMaxCoolSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePICoolingDemandWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::PICoolingDemand::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePICoolingDemandWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::PICoolingDemand::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePICoolingDemandWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::PICoolingDemand::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePIHeatingDemandWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::PIHeatingDemand::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePIHeatingDemandWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::PIHeatingDemand::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePIHeatingDemandWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::PIHeatingDemand::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeHVACSystemTypeConfigurationWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeHVACSystemTypeConfigurationWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeHVACSystemTypeConfigurationWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeHVACSystemTypeConfigurationWithValue:(NSNumber * _Nonnull)value
                                                    params:(MTRWriteParams * _Nullable)params
                                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeHVACSystemTypeConfigurationWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeHVACSystemTypeConfigurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                             endpoint:(NSNumber *)endpoint
                                                                queue:(dispatch_queue_t)queue
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLocalTemperatureCalibrationWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLocalTemperatureCalibrationWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLocalTemperatureCalibrationWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeLocalTemperatureCalibrationWithValue:(NSNumber * _Nonnull)value
                                                    params:(MTRWriteParams * _Nullable)params
                                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.charValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLocalTemperatureCalibrationWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLocalTemperatureCalibrationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                             endpoint:(NSNumber *)endpoint
                                                                queue:(dispatch_queue_t)queue
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupiedCoolingSetpointWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeOccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)value
                                                params:(MTRWriteParams * _Nullable)params
                                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOccupiedCoolingSetpointWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOccupiedCoolingSetpointWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupiedHeatingSetpointWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeOccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)value
                                                params:(MTRWriteParams * _Nullable)params
                                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOccupiedHeatingSetpointWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOccupiedHeatingSetpointWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUnoccupiedCoolingSetpointWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUnoccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeUnoccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeUnoccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)value
                                                  params:(MTRWriteParams * _Nullable)params
                                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeUnoccupiedCoolingSetpointWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUnoccupiedCoolingSetpointWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUnoccupiedHeatingSetpointWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUnoccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeUnoccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeUnoccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)value
                                                  params:(MTRWriteParams * _Nullable)params
                                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeUnoccupiedHeatingSetpointWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUnoccupiedHeatingSetpointWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinHeatSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeMinHeatSetpointLimitWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeMinHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeMinHeatSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinHeatSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxHeatSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeMaxHeatSetpointLimitWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeMaxHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeMaxHeatSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxHeatSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinCoolSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeMinCoolSetpointLimitWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeMinCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeMinCoolSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinCoolSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxCoolSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeMaxCoolSetpointLimitWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeMaxCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeMaxCoolSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxCoolSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinSetpointDeadBandWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinSetpointDeadBandWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeMinSetpointDeadBandWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeMinSetpointDeadBandWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.charValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeMinSetpointDeadBandWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinSetpointDeadBandWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRemoteSensingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRemoteSensingWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeRemoteSensingWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeRemoteSensingWithValue:(NSNumber * _Nonnull)value
                                      params:(MTRWriteParams * _Nullable)params
                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeRemoteSensingWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRemoteSensingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeControlSequenceOfOperationWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
            auto successFn = Callback<ThermostatClusterThermostatControlSequenceAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeControlSequenceOfOperationWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeControlSequenceOfOperationWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeControlSequenceOfOperationWithValue:(NSNumber * _Nonnull)value
                                                   params:(MTRWriteParams * _Nullable)params
                                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeControlSequenceOfOperationWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
            auto successFn = Callback<ThermostatClusterThermostatControlSequenceAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeControlSequenceOfOperationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ThermostatClusterThermostatControlSequenceAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeSystemModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSystemModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeSystemModeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeSystemModeWithValue:(NSNumber * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeSystemModeWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSystemModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeThermostatRunningModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::ThermostatRunningMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeThermostatRunningModeWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ThermostatRunningMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeThermostatRunningModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::ThermostatRunningMode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStartOfWeekWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeStartOfWeekWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeStartOfWeekWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfWeeklyTransitionsWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNumberOfWeeklyTransitionsWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNumberOfWeeklyTransitionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfDailyTransitionsWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNumberOfDailyTransitionsWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNumberOfDailyTransitionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTemperatureSetpointHoldWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTemperatureSetpointHoldWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeTemperatureSetpointHoldWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeTemperatureSetpointHoldWithValue:(NSNumber * _Nonnull)value
                                                params:(MTRWriteParams * _Nullable)params
                                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeTemperatureSetpointHoldWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTemperatureSetpointHoldWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTemperatureSetpointHoldDurationWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTemperatureSetpointHoldDurationWithValue:(NSNumber * _Nullable)value
                                                    completion:(MTRStatusCompletion)completion
{
    [self writeAttributeTemperatureSetpointHoldDurationWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeTemperatureSetpointHoldDurationWithValue:(NSNumber * _Nullable)value
                                                        params:(MTRWriteParams * _Nullable)params
                                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeTemperatureSetpointHoldDurationWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTemperatureSetpointHoldDurationWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeThermostatProgrammingOperationModeWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeThermostatProgrammingOperationModeWithValue:(NSNumber * _Nonnull)value
                                                       completion:(MTRStatusCompletion)completion
{
    [self writeAttributeThermostatProgrammingOperationModeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeThermostatProgrammingOperationModeWithValue:(NSNumber * _Nonnull)value
                                                           params:(MTRWriteParams * _Nullable)params
                                                       completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeThermostatProgrammingOperationModeWithParams:(MTRSubscribeParams * _Nonnull)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeThermostatProgrammingOperationModeWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                    endpoint:(NSNumber *)endpoint
                                                                       queue:(dispatch_queue_t)queue
                                                                  completion:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeThermostatRunningStateWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::ThermostatRunningState::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeThermostatRunningStateWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ThermostatRunningState::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeThermostatRunningStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::ThermostatRunningState::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSetpointChangeSourceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::SetpointChangeSource::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSetpointChangeSourceWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::SetpointChangeSource::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSetpointChangeSourceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::SetpointChangeSource::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSetpointChangeAmountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::SetpointChangeAmount::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSetpointChangeAmountWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::SetpointChangeAmount::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSetpointChangeAmountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::SetpointChangeAmount::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSetpointChangeSourceTimestampWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::SetpointChangeSourceTimestamp::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSetpointChangeSourceTimestampWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::SetpointChangeSourceTimestamp::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSetpointChangeSourceTimestampWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::SetpointChangeSourceTimestamp::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupiedSetbackWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOccupiedSetbackWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOccupiedSetbackWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeOccupiedSetbackWithValue:(NSNumber * _Nullable)value
                                        params:(MTRWriteParams * _Nullable)params
                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOccupiedSetbackWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOccupiedSetbackWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupiedSetbackMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMin::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOccupiedSetbackMinWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMin::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOccupiedSetbackMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMin::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupiedSetbackMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMax::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOccupiedSetbackMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMax::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOccupiedSetbackMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMax::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUnoccupiedSetbackWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUnoccupiedSetbackWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeUnoccupiedSetbackWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeUnoccupiedSetbackWithValue:(NSNumber * _Nullable)value
                                          params:(MTRWriteParams * _Nullable)params
                                      completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeUnoccupiedSetbackWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUnoccupiedSetbackWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUnoccupiedSetbackMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMin::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeUnoccupiedSetbackMinWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMin::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUnoccupiedSetbackMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMin::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUnoccupiedSetbackMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMax::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeUnoccupiedSetbackMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMax::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUnoccupiedSetbackMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMax::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEmergencyHeatDeltaWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEmergencyHeatDeltaWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeEmergencyHeatDeltaWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeEmergencyHeatDeltaWithValue:(NSNumber * _Nonnull)value
                                           params:(MTRWriteParams * _Nullable)params
                                       completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeEmergencyHeatDeltaWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEmergencyHeatDeltaWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeACTypeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeACTypeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeACTypeWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeACTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeACTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeACCapacityWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeACCapacityWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeACCapacityWithValue:(NSNumber * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeACCapacityWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeACCapacityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACRefrigerantTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeACRefrigerantTypeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeACRefrigerantTypeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeACRefrigerantTypeWithValue:(NSNumber * _Nonnull)value
                                          params:(MTRWriteParams * _Nullable)params
                                      completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeACRefrigerantTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeACRefrigerantTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACCompressorTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeACCompressorTypeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeACCompressorTypeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeACCompressorTypeWithValue:(NSNumber * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                                     completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeACCompressorTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeACCompressorTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACErrorCodeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeACErrorCodeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeACErrorCodeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeACErrorCodeWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeACErrorCodeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeACErrorCodeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACLouverPositionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeACLouverPositionWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeACLouverPositionWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeACLouverPositionWithValue:(NSNumber * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                                     completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeACLouverPositionWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeACLouverPositionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACCoilTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::ACCoilTemperature::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeACCoilTemperatureWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACCoilTemperature::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeACCoilTemperatureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::ACCoilTemperature::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACCapacityformatWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeACCapacityformatWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeACCapacityformatWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeACCapacityformatWithValue:(NSNumber * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                                     completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeACCapacityformatWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeACCapacityformatWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThermostatGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ThermostatGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ThermostatGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThermostatGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = Thermostat::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ThermostatGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThermostatAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ThermostatAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ThermostatAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThermostatAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = Thermostat::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ThermostatAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThermostatAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ThermostatAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ThermostatAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThermostatAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ThermostatAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterFanControl

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeFanModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFanControlClusterFanModeTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
            auto successFn = Callback<FanControlClusterFanModeTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFanModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeFanModeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeFanModeWithValue:(NSNumber * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeFanModeWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
            auto successFn = Callback<FanControlClusterFanModeTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFanModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFanControlClusterFanModeTypeAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<FanControlClusterFanModeTypeAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFanModeSequenceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
            auto successFn = Callback<FanControlClusterFanModeSequenceTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFanModeSequenceWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeFanModeSequenceWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeFanModeSequenceWithValue:(NSNumber * _Nonnull)value
                                        params:(MTRWriteParams * _Nullable)params
                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeFanModeSequenceWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
            auto successFn = Callback<FanControlClusterFanModeSequenceTypeAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFanModeSequenceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<FanControlClusterFanModeSequenceTypeAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributePercentSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePercentSettingWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributePercentSettingWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributePercentSettingWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributePercentSettingWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePercentSettingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePercentCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::PercentCurrent::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePercentCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::PercentCurrent::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePercentCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FanControl::Attributes::PercentCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSpeedMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::SpeedMax::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSpeedMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::SpeedMax::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSpeedMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FanControl::Attributes::SpeedMax::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSpeedSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSpeedSettingWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeSpeedSettingWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeSpeedSettingWithValue:(NSNumber * _Nullable)value
                                     params:(MTRWriteParams * _Nullable)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeSpeedSettingWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSpeedSettingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSpeedCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::SpeedCurrent::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSpeedCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::SpeedCurrent::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSpeedCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FanControl::Attributes::SpeedCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRockSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::RockSupport::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRockSupportWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::RockSupport::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRockSupportWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FanControl::Attributes::RockSupport::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRockSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRockSettingWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeRockSettingWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeRockSettingWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeRockSettingWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRockSettingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWindSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::WindSupport::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeWindSupportWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::WindSupport::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWindSupportWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FanControl::Attributes::WindSupport::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWindSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWindSettingWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeWindSettingWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeWindSettingWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeWindSettingWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWindSettingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFanControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<FanControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<FanControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFanControlGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = FanControl::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<FanControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFanControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<FanControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<FanControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFanControlAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = FanControl::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<FanControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFanControlAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<FanControlAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<FanControlAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFanControlAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FanControl::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<FanControlAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FanControl::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FanControl::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FanControl::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterThermostatUserInterfaceConfiguration

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeTemperatureDisplayModeWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTemperatureDisplayModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeTemperatureDisplayModeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeTemperatureDisplayModeWithValue:(NSNumber * _Nonnull)value
                                               params:(MTRWriteParams * _Nullable)params
                                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeTemperatureDisplayModeWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTemperatureDisplayModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeKeypadLockoutWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeKeypadLockoutWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeKeypadLockoutWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeKeypadLockoutWithValue:(NSNumber * _Nonnull)value
                                      params:(MTRWriteParams * _Nullable)params
                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeKeypadLockoutWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeKeypadLockoutWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeScheduleProgrammingVisibilityWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeScheduleProgrammingVisibilityWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeScheduleProgrammingVisibilityWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeScheduleProgrammingVisibilityWithValue:(NSNumber * _Nonnull)value
                                                      params:(MTRWriteParams * _Nullable)params
                                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeScheduleProgrammingVisibilityWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeScheduleProgrammingVisibilityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device,
        completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn
                = Callback<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn
                = Callback<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(
                        success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device,
        completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn
                = Callback<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn
                = Callback<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(
                        success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo;
            auto successFn
                = Callback<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo;
            auto successFn
                = Callback<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterColorControl

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)moveToHueWithParams:(MTRColorControlClusterMoveToHueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)moveHueWithParams:(MTRColorControlClusterMoveHueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)stepHueWithParams:(MTRColorControlClusterStepHueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)moveToSaturationWithParams:(MTRColorControlClusterMoveToSaturationParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)moveSaturationWithParams:(MTRColorControlClusterMoveSaturationParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)stepSaturationWithParams:(MTRColorControlClusterStepSaturationParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)moveToHueAndSaturationWithParams:(MTRColorControlClusterMoveToHueAndSaturationParams *)params
                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)moveToColorWithParams:(MTRColorControlClusterMoveToColorParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)moveColorWithParams:(MTRColorControlClusterMoveColorParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)stepColorWithParams:(MTRColorControlClusterStepColorParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)moveToColorTemperatureWithParams:(MTRColorControlClusterMoveToColorTemperatureParams *)params
                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)enhancedMoveToHueWithParams:(MTRColorControlClusterEnhancedMoveToHueParams *)params
                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)enhancedMoveHueWithParams:(MTRColorControlClusterEnhancedMoveHueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)enhancedStepHueWithParams:(MTRColorControlClusterEnhancedStepHueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)enhancedMoveToHueAndSaturationWithParams:(MTRColorControlClusterEnhancedMoveToHueAndSaturationParams *)params
                                      completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)colorLoopSetWithParams:(MTRColorControlClusterColorLoopSetParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)stopMoveStepWithParams:(MTRColorControlClusterStopMoveStepParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)moveColorTemperatureWithParams:(MTRColorControlClusterMoveColorTemperatureParams *)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)stepColorTemperatureWithParams:(MTRColorControlClusterStepColorTemperatureParams *)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeCurrentHueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentHueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentHueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentSaturationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentSaturationWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentSaturationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRemainingTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRemainingTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRemainingTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentXWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentXWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentYWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentYWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDriftCompensationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDriftCompensationWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDriftCompensationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCompensationTextWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCompensationTextWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCompensationTextWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorTemperatureMiredsWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorTemperatureMireds::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeColorTemperatureMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorTemperatureMireds::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorTemperatureMiredsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorTemperatureMireds::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeColorModeWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOptionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOptionsWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOptionsWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOptionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfPrimariesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNumberOfPrimariesWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNumberOfPrimariesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary1XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary1XWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary1XWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary1YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary1YWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary1YWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary1IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary1IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary1IntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary2XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary2XWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary2XWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary2YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary2YWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary2YWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary2IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary2IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary2IntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary3XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary3XWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary3XWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary3YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary3YWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary3YWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary3IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary3IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary3IntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary4XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary4XWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary4XWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary4YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary4YWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary4YWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary4IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary4IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary4IntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary5XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary5XWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary5XWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary5YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary5YWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary5YWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary5IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary5IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary5IntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary6XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary6XWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary6XWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary6YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary6YWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary6YWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary6IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePrimary6IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePrimary6IntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWhitePointXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWhitePointXWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeWhitePointXWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeWhitePointXWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeWhitePointXWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWhitePointXWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWhitePointYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWhitePointYWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeWhitePointYWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeWhitePointYWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeWhitePointYWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWhitePointYWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointRXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorPointRXWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeColorPointRXWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeColorPointRXWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeColorPointRXWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorPointRXWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointRYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorPointRYWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeColorPointRYWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeColorPointRYWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeColorPointRYWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorPointRYWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointRIntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorPointRIntensityWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeColorPointRIntensityWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeColorPointRIntensityWithValue:(NSNumber * _Nullable)value
                                             params:(MTRWriteParams * _Nullable)params
                                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeColorPointRIntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorPointRIntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointGXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorPointGXWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeColorPointGXWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeColorPointGXWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeColorPointGXWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorPointGXWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointGYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorPointGYWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeColorPointGYWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeColorPointGYWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeColorPointGYWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorPointGYWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointGIntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorPointGIntensityWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeColorPointGIntensityWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeColorPointGIntensityWithValue:(NSNumber * _Nullable)value
                                             params:(MTRWriteParams * _Nullable)params
                                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeColorPointGIntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorPointGIntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointBXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorPointBXWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeColorPointBXWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeColorPointBXWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeColorPointBXWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorPointBXWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointBYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorPointBYWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeColorPointBYWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeColorPointBYWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeColorPointBYWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorPointBYWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointBIntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorPointBIntensityWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeColorPointBIntensityWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeColorPointBIntensityWithValue:(NSNumber * _Nullable)value
                                             params:(MTRWriteParams * _Nullable)params
                                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeColorPointBIntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorPointBIntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnhancedCurrentHueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeEnhancedCurrentHueWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEnhancedCurrentHueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnhancedColorModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeEnhancedColorModeWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEnhancedColorModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorLoopActiveWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeColorLoopActiveWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorLoopActiveWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorLoopDirectionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeColorLoopDirectionWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorLoopDirectionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorLoopTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeColorLoopTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorLoopTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorLoopStartEnhancedHueWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeColorLoopStartEnhancedHueWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorLoopStartEnhancedHueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorLoopStoredEnhancedHueWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeColorLoopStoredEnhancedHueWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorLoopStoredEnhancedHueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorCapabilitiesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeColorCapabilitiesWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorCapabilitiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorTempPhysicalMinMiredsWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMinMireds::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeColorTempPhysicalMinMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMinMireds::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorTempPhysicalMinMiredsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMinMireds::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorTempPhysicalMaxMiredsWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMaxMireds::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeColorTempPhysicalMaxMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMaxMireds::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeColorTempPhysicalMaxMiredsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMaxMireds::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCoupleColorTempToLevelMinMiredsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCoupleColorTempToLevelMinMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCoupleColorTempToLevelMinMiredsWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStartUpColorTemperatureMiredsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeStartUpColorTemperatureMiredsWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeStartUpColorTemperatureMiredsWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeStartUpColorTemperatureMiredsWithValue:(NSNumber * _Nullable)value
                                                      params:(MTRWriteParams * _Nullable)params
                                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeStartUpColorTemperatureMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeStartUpColorTemperatureMiredsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRColorControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ColorControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ColorControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRColorControlGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ColorControl::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ColorControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRColorControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ColorControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ColorControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRColorControlAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ColorControl::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ColorControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRColorControlAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ColorControlAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ColorControlAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRColorControlAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ColorControlAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBallastConfiguration

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributePhysicalMinLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::PhysicalMinLevel::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePhysicalMinLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::PhysicalMinLevel::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePhysicalMinLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::PhysicalMinLevel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhysicalMaxLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::PhysicalMaxLevel::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePhysicalMaxLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::PhysicalMaxLevel::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePhysicalMaxLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::PhysicalMaxLevel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBallastStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::BallastStatus::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeBallastStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::BallastStatus::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBallastStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::BallastStatus::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinLevelWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeMinLevelWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeMinLevelWithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeMinLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxLevelWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeMaxLevelWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeMaxLevelWithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeMaxLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeIntrinsicBalanceFactorWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::IntrinsicBalanceFactor::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeIntrinsicBalanceFactorWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeIntrinsicBalanceFactorWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeIntrinsicBalanceFactorWithValue:(NSNumber * _Nullable)value
                                               params:(MTRWriteParams * _Nullable)params
                                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BallastConfiguration::Attributes::IntrinsicBalanceFactor::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeIntrinsicBalanceFactorWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::IntrinsicBalanceFactor::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeIntrinsicBalanceFactorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::IntrinsicBalanceFactor::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBallastFactorAdjustmentWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBallastFactorAdjustmentWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBallastFactorAdjustmentWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeBallastFactorAdjustmentWithValue:(NSNumber * _Nullable)value
                                                params:(MTRWriteParams * _Nullable)params
                                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBallastFactorAdjustmentWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBallastFactorAdjustmentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampQuantityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::LampQuantity::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLampQuantityWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampQuantity::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLampQuantityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::LampQuantity::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampTypeWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLampTypeWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLampTypeWithValue:(NSString * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeLampTypeWithValue:(NSString * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLampTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLampTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampManufacturerWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLampManufacturerWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLampManufacturerWithValue:(NSString * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeLampManufacturerWithValue:(NSString * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                                     completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLampManufacturerWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLampManufacturerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampRatedHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLampRatedHoursWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLampRatedHoursWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeLampRatedHoursWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedIntValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLampRatedHoursWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLampRatedHoursWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampBurnHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLampBurnHoursWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLampBurnHoursWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeLampBurnHoursWithValue:(NSNumber * _Nullable)value
                                      params:(MTRWriteParams * _Nullable)params
                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedIntValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLampBurnHoursWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLampBurnHoursWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampAlarmModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLampAlarmModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLampAlarmModeWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeLampAlarmModeWithValue:(NSNumber * _Nonnull)value
                                      params:(MTRWriteParams * _Nullable)params
                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLampAlarmModeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLampAlarmModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampBurnHoursTripPointWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLampBurnHoursTripPointWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLampBurnHoursTripPointWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeLampBurnHoursTripPointWithValue:(NSNumber * _Nullable)value
                                               params:(MTRWriteParams * _Nullable)params
                                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedIntValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLampBurnHoursTripPointWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLampBurnHoursTripPointWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BallastConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<BallastConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = BallastConfiguration::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<BallastConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BallastConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<BallastConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = BallastConfiguration::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<BallastConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBallastConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BallastConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<BallastConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBallastConfigurationAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = BallastConfiguration::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<BallastConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = BallastConfiguration::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = BallastConfiguration::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterIlluminanceMeasurement

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeToleranceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLightSensorTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLightSensorTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLightSensorTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = IlluminanceMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = IlluminanceMeasurement::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = IlluminanceMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = IlluminanceMeasurement::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<IlluminanceMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<IlluminanceMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<IlluminanceMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = IlluminanceMeasurement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = IlluminanceMeasurement::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterTemperatureMeasurement

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeToleranceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TemperatureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<TemperatureMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<TemperatureMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TemperatureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TemperatureMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TemperatureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<TemperatureMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<TemperatureMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TemperatureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TemperatureMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<TemperatureMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<TemperatureMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TemperatureMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TemperatureMeasurement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TemperatureMeasurement::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterPressureMeasurement

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::Tolerance::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::Tolerance::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeToleranceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PressureMeasurement::Attributes::Tolerance::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeScaledValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::ScaledValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeScaledValueWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::ScaledValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeScaledValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PressureMeasurement::Attributes::ScaledValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinScaledValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::MinScaledValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinScaledValueWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::MinScaledValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinScaledValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PressureMeasurement::Attributes::MinScaledValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxScaledValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::MaxScaledValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxScaledValueWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::MaxScaledValue::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxScaledValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PressureMeasurement::Attributes::MaxScaledValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeScaledToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::ScaledTolerance::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeScaledToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::ScaledTolerance::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeScaledToleranceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PressureMeasurement::Attributes::ScaledTolerance::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeScaleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::Scale::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeScaleWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::Scale::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeScaleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PressureMeasurement::Attributes::Scale::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<PressureMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<PressureMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PressureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PressureMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<PressureMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<PressureMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PressureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PressureMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPressureMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<PressureMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<PressureMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRPressureMeasurementAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = PressureMeasurement::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<PressureMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PressureMeasurement::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterFlowMeasurement

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeToleranceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FlowMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<FlowMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<FlowMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = FlowMeasurement::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<FlowMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FlowMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<FlowMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<FlowMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = FlowMeasurement::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<FlowMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFlowMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FlowMeasurement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<FlowMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<FlowMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFlowMeasurementAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = FlowMeasurement::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<FlowMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FlowMeasurement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FlowMeasurement::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterRelativeHumidityMeasurement

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeToleranceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn
                = Callback<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn
                = Callback<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = RelativeHumidityMeasurement::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn
                    = Callback<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<RelativeHumidityMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<RelativeHumidityMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<RelativeHumidityMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterOccupancySensing

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeOccupancyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOccupancyWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOccupancyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupancySensorTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOccupancySensorTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOccupancySensorTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupancySensorTypeBitmapWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOccupancySensorTypeBitmapWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOccupancySensorTypeBitmapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePIROccupiedToUnoccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::PirOccupiedToUnoccupiedDelay::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePIROccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributePIROccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributePIROccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                     params:(MTRWriteParams * _Nullable)params
                                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::PirOccupiedToUnoccupiedDelay::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributePIROccupiedToUnoccupiedDelayWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::PirOccupiedToUnoccupiedDelay::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePIROccupiedToUnoccupiedDelayWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::PirOccupiedToUnoccupiedDelay::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePIRUnoccupiedToOccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedDelay::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePIRUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributePIRUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributePIRUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                     params:(MTRWriteParams * _Nullable)params
                                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedDelay::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributePIRUnoccupiedToOccupiedDelayWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedDelay::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePIRUnoccupiedToOccupiedDelayWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedDelay::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePIRUnoccupiedToOccupiedThresholdWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedThreshold::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePIRUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
                                                     completion:(MTRStatusCompletion)completion
{
    [self writeAttributePIRUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributePIRUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
                                                         params:(MTRWriteParams * _Nullable)params
                                                     completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedThreshold::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributePIRUnoccupiedToOccupiedThresholdWithParams:(MTRSubscribeParams * _Nonnull)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedThreshold::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePIRUnoccupiedToOccupiedThresholdWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedThreshold::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUltrasonicOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                        completion:(MTRStatusCompletion)completion
{
    [self writeAttributeUltrasonicOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeUltrasonicOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                            params:(MTRWriteParams * _Nullable)params
                                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeUltrasonicOccupiedToUnoccupiedDelayWithParams:(MTRSubscribeParams * _Nonnull)params
                                                subscriptionEstablished:
                                                    (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                          reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                     endpoint:(NSNumber *)endpoint
                                                                        queue:(dispatch_queue_t)queue
                                                                   completion:(void (^)(NSNumber * _Nullable value,
                                                                                  NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUltrasonicUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                        completion:(MTRStatusCompletion)completion
{
    [self writeAttributeUltrasonicUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeUltrasonicUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                            params:(MTRWriteParams * _Nullable)params
                                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeUltrasonicUnoccupiedToOccupiedDelayWithParams:(MTRSubscribeParams * _Nonnull)params
                                                subscriptionEstablished:
                                                    (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                          reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                     endpoint:(NSNumber *)endpoint
                                                                        queue:(dispatch_queue_t)queue
                                                                   completion:(void (^)(NSNumber * _Nullable value,
                                                                                  NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
                                                            completion:(MTRStatusCompletion)completion
{
    [self writeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull) value
                                                                  params:nil
                                                              completion:completion];
}
- (void)writeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
                                                                params:(MTRWriteParams * _Nullable)params
                                                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithParams:(MTRSubscribeParams * _Nonnull)params
                                                    subscriptionEstablished:
                                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                              reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                         endpoint:(NSNumber *)endpoint
                                                                            queue:(dispatch_queue_t)queue
                                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                                      NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePhysicalContactOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                             completion:(MTRStatusCompletion)completion
{
    [self writeAttributePhysicalContactOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull) value
                                                                   params:nil
                                                               completion:completion];
}
- (void)writeAttributePhysicalContactOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                                 params:(MTRWriteParams * _Nullable)params
                                                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributePhysicalContactOccupiedToUnoccupiedDelayWithParams:(MTRSubscribeParams * _Nonnull)params
                                                     subscriptionEstablished:
                                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                               reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                          endpoint:(NSNumber *)endpoint
                                                                             queue:(dispatch_queue_t)queue
                                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                                       NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePhysicalContactUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                             completion:(MTRStatusCompletion)completion
{
    [self writeAttributePhysicalContactUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull) value
                                                                   params:nil
                                                               completion:completion];
}
- (void)writeAttributePhysicalContactUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                                 params:(MTRWriteParams * _Nullable)params
                                                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributePhysicalContactUnoccupiedToOccupiedDelayWithParams:(MTRSubscribeParams * _Nonnull)params
                                                     subscriptionEstablished:
                                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                               reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                          endpoint:(NSNumber *)endpoint
                                                                             queue:(dispatch_queue_t)queue
                                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                                       NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
                                                                 completion:(MTRStatusCompletion)completion
{
    [self writeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull) value
                                                                       params:nil
                                                                   completion:completion];
}
- (void)writeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
                                                                     params:(MTRWriteParams * _Nullable)params
                                                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithParams:(MTRSubscribeParams * _Nonnull)params
                                                         subscriptionEstablished:
                                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                     NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                              endpoint:(NSNumber *)endpoint
                                                                                 queue:(dispatch_queue_t)queue
                                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                                           NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<OccupancySensingGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<OccupancySensingGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OccupancySensing::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<OccupancySensingGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<OccupancySensingAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<OccupancySensingAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OccupancySensing::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<OccupancySensingAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROccupancySensingAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<OccupancySensingAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<OccupancySensingAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTROccupancySensingAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = OccupancySensing::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<OccupancySensingAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterWakeOnLAN

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeMACAddressWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WakeOnLan::Attributes::MACAddress::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMACAddressWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WakeOnLan::Attributes::MACAddress::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMACAddressWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WakeOnLan::Attributes::MACAddress::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWakeOnLANGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WakeOnLan::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<WakeOnLANGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWakeOnLANGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WakeOnLan::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<WakeOnLANGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWakeOnLANGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWakeOnLANGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = WakeOnLan::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<WakeOnLANGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWakeOnLANAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WakeOnLan::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<WakeOnLANAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWakeOnLANAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WakeOnLan::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<WakeOnLANAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWakeOnLANAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWakeOnLANAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = WakeOnLan::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<WakeOnLANAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWakeOnLANAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WakeOnLan::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<WakeOnLANAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRWakeOnLANAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WakeOnLan::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<WakeOnLANAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWakeOnLANAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRWakeOnLANAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WakeOnLan::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<WakeOnLANAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WakeOnLan::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WakeOnLan::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WakeOnLan::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterChannel

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)changeChannelWithParams:(MTRChannelClusterChangeChannelParams *)params
                     completion:(void (^)(MTRChannelClusterChangeChannelResponseParams * _Nullable data,
                                    NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRChannelClusterChangeChannelResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)changeChannelByNumberWithParams:(MTRChannelClusterChangeChannelByNumberParams *)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)skipChannelWithParams:(MTRChannelClusterSkipChannelParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeChannelListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRChannelChannelListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Channel::Attributes::ChannelList::TypeInfo;
            auto successFn = Callback<ChannelChannelListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeChannelListWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRChannelChannelListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::ChannelList::TypeInfo;
            auto successFn = Callback<ChannelChannelListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRChannelChannelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeChannelListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRChannelChannelListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Channel::Attributes::ChannelList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ChannelChannelListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLineupWithCompletion:(void (^)(
                                              MTRChannelClusterLineupInfo * _Nullable value, NSError * _Nullable error))completion
{
    new MTRChannelLineupStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Channel::Attributes::Lineup::TypeInfo;
            auto successFn = Callback<ChannelLineupStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLineupWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:
                                 (void (^)(MTRChannelClusterLineupInfo * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRChannelLineupStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::Lineup::TypeInfo;
            auto successFn = Callback<ChannelLineupStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRChannelLineupStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLineupWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(MTRChannelClusterLineupInfo * _Nullable value,
                                                     NSError * _Nullable error))completion
{
    new MTRChannelLineupStructAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Channel::Attributes::Lineup::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ChannelLineupStructAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentChannelWithCompletion:(void (^)(MTRChannelClusterChannelInfo * _Nullable value,
                                                      NSError * _Nullable error))completion
{
    new MTRChannelCurrentChannelStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Channel::Attributes::CurrentChannel::TypeInfo;
            auto successFn = Callback<ChannelCurrentChannelStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentChannelWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(MTRChannelClusterChannelInfo * _Nullable value,
                                                       NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::CurrentChannel::TypeInfo;
            auto successFn = Callback<ChannelCurrentChannelStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentChannelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(MTRChannelClusterChannelInfo * _Nullable value,
                                                             NSError * _Nullable error))completion
{
    new MTRChannelCurrentChannelStructAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Channel::Attributes::CurrentChannel::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ChannelCurrentChannelStructAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRChannelGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Channel::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ChannelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ChannelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRChannelGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Channel::Attributes::GeneratedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ChannelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRChannelAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Channel::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ChannelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ChannelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRChannelAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Channel::Attributes::AcceptedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ChannelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRChannelAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Channel::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ChannelAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRChannelAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ChannelAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRChannelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRChannelAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Channel::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ChannelAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Channel::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Channel::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = Channel::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = Channel::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterTargetNavigator

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)navigateTargetWithParams:(MTRTargetNavigatorClusterNavigateTargetParams *)params
                      completion:(void (^)(MTRTargetNavigatorClusterNavigateTargetResponseParams * _Nullable data,
                                     NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)readAttributeTargetListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTargetNavigatorTargetListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TargetNavigator::Attributes::TargetList::TypeInfo;
            auto successFn = Callback<TargetNavigatorTargetListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTargetListWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::TargetList::TypeInfo;
            auto successFn = Callback<TargetNavigatorTargetListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTargetListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTargetNavigatorTargetListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TargetNavigator::Attributes::TargetList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TargetNavigatorTargetListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentTargetWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TargetNavigator::Attributes::CurrentTarget::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentTargetWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::CurrentTarget::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentTargetWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TargetNavigator::Attributes::CurrentTarget::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TargetNavigator::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<TargetNavigatorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<TargetNavigatorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TargetNavigator::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TargetNavigatorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TargetNavigator::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<TargetNavigatorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<TargetNavigatorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TargetNavigator::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TargetNavigatorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTargetNavigatorAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TargetNavigator::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<TargetNavigatorAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<TargetNavigatorAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTargetNavigatorAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TargetNavigator::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TargetNavigatorAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TargetNavigator::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TargetNavigator::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterMediaPlayback

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)playWithCompletion:(void (^)(
                               MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self playWithParams:nil completion:completion];
}
- (void)playWithParams:(MTRMediaPlaybackClusterPlayParams * _Nullable)params
            completion:
                (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)pauseWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                NSError * _Nullable error))completion
{
    [self pauseWithParams:nil completion:completion];
}
- (void)pauseWithParams:(MTRMediaPlaybackClusterPauseParams * _Nullable)params
             completion:
                 (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)stopPlaybackWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                       NSError * _Nullable error))completion
{
    [self stopPlaybackWithParams:nil completion:completion];
}
- (void)stopPlaybackWithParams:(MTRMediaPlaybackClusterStopPlaybackParams * _Nullable)params
                    completion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                   NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)startOverWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                    NSError * _Nullable error))completion
{
    [self startOverWithParams:nil completion:completion];
}
- (void)startOverWithParams:(MTRMediaPlaybackClusterStartOverParams * _Nullable)params
                 completion:
                     (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)previousWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                   NSError * _Nullable error))completion
{
    [self previousWithParams:nil completion:completion];
}
- (void)previousWithParams:(MTRMediaPlaybackClusterPreviousParams * _Nullable)params
                completion:
                    (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)nextWithCompletion:(void (^)(
                               MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self nextWithParams:nil completion:completion];
}
- (void)nextWithParams:(MTRMediaPlaybackClusterNextParams * _Nullable)params
            completion:
                (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)rewindWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                 NSError * _Nullable error))completion
{
    [self rewindWithParams:nil completion:completion];
}
- (void)rewindWithParams:(MTRMediaPlaybackClusterRewindParams * _Nullable)params
              completion:
                  (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)fastForwardWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                      NSError * _Nullable error))completion
{
    [self fastForwardWithParams:nil completion:completion];
}
- (void)fastForwardWithParams:(MTRMediaPlaybackClusterFastForwardParams * _Nullable)params
                   completion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                  NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)skipForwardWithParams:(MTRMediaPlaybackClusterSkipForwardParams *)params
                   completion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                  NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)skipBackwardWithParams:(MTRMediaPlaybackClusterSkipBackwardParams *)params
                    completion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                   NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)seekWithParams:(MTRMediaPlaybackClusterSeekParams *)params
            completion:
                (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)readAttributeCurrentStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaPlayback::Attributes::CurrentState::TypeInfo;
            auto successFn = Callback<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentStateWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::CurrentState::TypeInfo;
            auto successFn = Callback<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = MediaPlayback::Attributes::CurrentState::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeStartTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeStartTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeStartTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDurationWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSampledPositionWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackPosition * _Nullable value,
                                                       NSError * _Nullable error))completion
{
    new MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaPlayback::Attributes::SampledPosition::TypeInfo;
            auto successFn = Callback<MediaPlaybackSampledPositionStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSampledPositionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(MTRMediaPlaybackClusterPlaybackPosition * _Nullable value,
                                                        NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::SampledPosition::TypeInfo;
            auto successFn = Callback<MediaPlaybackSampledPositionStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSampledPositionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(MTRMediaPlaybackClusterPlaybackPosition * _Nullable value,
                                                              NSError * _Nullable error))completion
{
    new MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = MediaPlayback::Attributes::SampledPosition::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<MediaPlaybackSampledPositionStructAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributePlaybackSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFloatAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo;
            auto successFn = Callback<FloatAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePlaybackSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFloatAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo;
            auto successFn = Callback<FloatAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePlaybackSpeedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFloatAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<FloatAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSeekRangeEndWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSeekRangeEndWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSeekRangeEndWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSeekRangeStartWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeSeekRangeStartWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSeekRangeStartWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaPlayback::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<MediaPlaybackGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<MediaPlaybackGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = MediaPlayback::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<MediaPlaybackGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaPlayback::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<MediaPlaybackAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<MediaPlaybackAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = MediaPlayback::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<MediaPlaybackAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaPlaybackAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<MediaPlaybackAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<MediaPlaybackAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaPlaybackAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<MediaPlaybackAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaPlayback::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = MediaPlayback::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterMediaInput

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)selectInputWithParams:(MTRMediaInputClusterSelectInputParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)showInputStatusWithCompletion:(MTRStatusCompletion)completion
{
    [self showInputStatusWithParams:nil completion:completion];
}
- (void)showInputStatusWithParams:(MTRMediaInputClusterShowInputStatusParams * _Nullable)params
                       completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)hideInputStatusWithCompletion:(MTRStatusCompletion)completion
{
    [self hideInputStatusWithParams:nil completion:completion];
}
- (void)hideInputStatusWithParams:(MTRMediaInputClusterHideInputStatusParams * _Nullable)params
                       completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)renameInputWithParams:(MTRMediaInputClusterRenameInputParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeInputListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaInputInputListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaInput::Attributes::InputList::TypeInfo;
            auto successFn = Callback<MediaInputInputListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeInputListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaInputInputListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::InputList::TypeInfo;
            auto successFn = Callback<MediaInputInputListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaInputInputListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInputListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaInputInputListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = MediaInput::Attributes::InputList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<MediaInputInputListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentInputWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaInput::Attributes::CurrentInput::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentInputWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::CurrentInput::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentInputWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = MediaInput::Attributes::CurrentInput::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaInput::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<MediaInputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<MediaInputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = MediaInput::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<MediaInputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaInput::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<MediaInputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<MediaInputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = MediaInput::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<MediaInputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaInputAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaInput::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<MediaInputAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<MediaInputAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRMediaInputAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = MediaInput::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<MediaInputAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaInput::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = MediaInput::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterLowPower

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)sleepWithCompletion:(MTRStatusCompletion)completion
{
    [self sleepWithParams:nil completion:completion];
}
- (void)sleepWithParams:(MTRLowPowerClusterSleepParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LowPower::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<LowPowerGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LowPower::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<LowPowerGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = LowPower::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<LowPowerGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LowPower::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<LowPowerAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LowPower::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<LowPowerAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LowPower::Attributes::AcceptedCommandList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<LowPowerAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLowPowerAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LowPower::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<LowPowerAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LowPower::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<LowPowerAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRLowPowerAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LowPower::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<LowPowerAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LowPower::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LowPower::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LowPower::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterKeypadInput

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)sendKeyWithParams:(MTRKeypadInputClusterSendKeyParams *)params
               completion:
                   (void (^)(MTRKeypadInputClusterSendKeyResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRKeypadInputClusterSendKeyResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = KeypadInput::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<KeypadInputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = KeypadInput::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<KeypadInputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = KeypadInput::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<KeypadInputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = KeypadInput::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<KeypadInputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = KeypadInput::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<KeypadInputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = KeypadInput::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<KeypadInputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRKeypadInputAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = KeypadInput::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<KeypadInputAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = KeypadInput::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<KeypadInputAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRKeypadInputAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = KeypadInput::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<KeypadInputAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = KeypadInput::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = KeypadInput::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = KeypadInput::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterContentLauncher

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)launchContentWithParams:(MTRContentLauncherClusterLaunchContentParams *)params
                     completion:(void (^)(MTRContentLauncherClusterLaunchResponseParams * _Nullable data,
                                    NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)launchURLWithParams:(MTRContentLauncherClusterLaunchURLParams *)params
                 completion:
                     (void (^)(MTRContentLauncherClusterLaunchResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)readAttributeAcceptHeaderWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ContentLauncher::Attributes::AcceptHeader::TypeInfo;
            auto successFn = Callback<ContentLauncherAcceptHeaderListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptHeaderWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::AcceptHeader::TypeInfo;
            auto successFn = Callback<ContentLauncherAcceptHeaderListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptHeaderWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ContentLauncher::Attributes::AcceptHeader::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<ContentLauncherAcceptHeaderListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSupportedStreamingProtocolsWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSupportedStreamingProtocolsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeSupportedStreamingProtocolsWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeSupportedStreamingProtocolsWithValue:(NSNumber * _Nonnull)value
                                                    params:(MTRWriteParams * _Nullable)params
                                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeSupportedStreamingProtocolsWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeSupportedStreamingProtocolsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                             endpoint:(NSNumber *)endpoint
                                                                queue:(dispatch_queue_t)queue
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ContentLauncher::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ContentLauncherGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ContentLauncherGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ContentLauncher::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ContentLauncherGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ContentLauncher::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ContentLauncherAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ContentLauncherAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ContentLauncher::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ContentLauncherAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRContentLauncherAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ContentLauncher::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ContentLauncherAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ContentLauncherAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRContentLauncherAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ContentLauncher::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ContentLauncherAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ContentLauncher::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ContentLauncher::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterAudioOutput

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)selectOutputWithParams:(MTRAudioOutputClusterSelectOutputParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)renameOutputWithParams:(MTRAudioOutputClusterRenameOutputParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeOutputListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAudioOutputOutputListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AudioOutput::Attributes::OutputList::TypeInfo;
            auto successFn = Callback<AudioOutputOutputListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeOutputListWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::OutputList::TypeInfo;
            auto successFn = Callback<AudioOutputOutputListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOutputListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAudioOutputOutputListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AudioOutput::Attributes::OutputList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<AudioOutputOutputListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentOutputWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AudioOutput::Attributes::CurrentOutput::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentOutputWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::CurrentOutput::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentOutputWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AudioOutput::Attributes::CurrentOutput::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AudioOutput::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<AudioOutputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<AudioOutputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = AudioOutput::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<AudioOutputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AudioOutput::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<AudioOutputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<AudioOutputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = AudioOutput::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<AudioOutputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAudioOutputAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AudioOutput::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<AudioOutputAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<AudioOutputAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAudioOutputAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AudioOutput::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<AudioOutputAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AudioOutput::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AudioOutput::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterApplicationLauncher

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)launchAppWithParams:(MTRApplicationLauncherClusterLaunchAppParams *)params
                 completion:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data,
                                NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)stopAppWithParams:(MTRApplicationLauncherClusterStopAppParams *)params
               completion:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data,
                              NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)hideAppWithParams:(MTRApplicationLauncherClusterHideAppParams *)params
               completion:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data,
                              NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)readAttributeCatalogListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationLauncherCatalogListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationLauncher::Attributes::CatalogList::TypeInfo;
            auto successFn = Callback<ApplicationLauncherCatalogListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCatalogListWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::CatalogList::TypeInfo;
            auto successFn = Callback<ApplicationLauncherCatalogListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCatalogListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationLauncherCatalogListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ApplicationLauncher::Attributes::CatalogList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ApplicationLauncherCatalogListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeCurrentAppWithCompletion:(void (^)(MTRApplicationLauncherClusterApplicationEP * _Nullable value,
                                                  NSError * _Nullable error))completion
{
    new MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
            auto successFn = Callback<ApplicationLauncherCurrentAppStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentAppWithValue:(MTRApplicationLauncherClusterApplicationEP * _Nullable)value
                               completion:(MTRStatusCompletion)completion
{
    [self writeAttributeCurrentAppWithValue:(MTRApplicationLauncherClusterApplicationEP * _Nullable) value
                                     params:nil
                                 completion:completion];
}
- (void)writeAttributeCurrentAppWithValue:(MTRApplicationLauncherClusterApplicationEP * _Nullable)value
                                   params:(MTRWriteParams * _Nullable)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0.application.catalogVendorId = value.application.catalogVendorId.unsignedShortValue;
                nonNullValue_0.application.applicationId = [self asCharSpan:value.application.applicationId];
                if (value.endpoint != nil) {
                    auto & definedValue_2 = nonNullValue_0.endpoint.Emplace();
                    definedValue_2 = value.endpoint.unsignedShortValue;
                }
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeCurrentAppWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(MTRApplicationLauncherClusterApplicationEP * _Nullable value,
                                                   NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
            auto successFn = Callback<ApplicationLauncherCurrentAppStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentAppWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(MTRApplicationLauncherClusterApplicationEP * _Nullable value,
                                                         NSError * _Nullable error))completion
{
    new MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ApplicationLauncherCurrentAppStructAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationLauncher::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ApplicationLauncherGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ApplicationLauncherGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ApplicationLauncher::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ApplicationLauncherGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationLauncher::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ApplicationLauncherAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ApplicationLauncherAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ApplicationLauncher::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ApplicationLauncherAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationLauncherAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationLauncher::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ApplicationLauncherAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ApplicationLauncherAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationLauncherAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ApplicationLauncher::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ApplicationLauncherAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationLauncher::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ApplicationLauncher::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterApplicationBasic

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)readAttributeVendorNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeVendorNameWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeVendorNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeVendorIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationBasic::Attributes::VendorID::TypeInfo;
            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeVendorIDWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRVendorIdAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::VendorID::TypeInfo;
            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeVendorIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ApplicationBasic::Attributes::VendorID::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeApplicationNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeApplicationNameWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeApplicationNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationBasic::Attributes::ProductID::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeProductIDWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::ProductID::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeProductIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ApplicationBasic::Attributes::ProductID::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeApplicationWithCompletion:(void (^)(MTRApplicationBasicClusterApplicationBasicApplication * _Nullable value,
                                                   NSError * _Nullable error))completion
{
    new MTRApplicationBasicApplicationStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationBasic::Attributes::Application::TypeInfo;
            auto successFn = Callback<ApplicationBasicApplicationStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeApplicationWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(MTRApplicationBasicClusterApplicationBasicApplication * _Nullable value,
                                                    NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::Application::TypeInfo;
            auto successFn = Callback<ApplicationBasicApplicationStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeApplicationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:
                                               (void (^)(MTRApplicationBasicClusterApplicationBasicApplication * _Nullable value,
                                                   NSError * _Nullable error))completion
{
    new MTRApplicationBasicApplicationStructAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ApplicationBasic::Attributes::Application::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ApplicationBasicApplicationStructAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationBasic::Attributes::Status::TypeInfo;
            auto successFn = Callback<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::Status::TypeInfo;
            auto successFn = Callback<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ApplicationBasic::Attributes::Status::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeApplicationVersionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationBasic::Attributes::ApplicationVersion::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeApplicationVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::ApplicationVersion::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeApplicationVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ApplicationBasic::Attributes::ApplicationVersion::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAllowedVendorListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationBasic::Attributes::AllowedVendorList::TypeInfo;
            auto successFn = Callback<ApplicationBasicAllowedVendorListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAllowedVendorListWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::AllowedVendorList::TypeInfo;
            auto successFn = Callback<ApplicationBasicAllowedVendorListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAllowedVendorListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ApplicationBasic::Attributes::AllowedVendorList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ApplicationBasicAllowedVendorListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationBasic::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ApplicationBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ApplicationBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ApplicationBasic::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ApplicationBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationBasic::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ApplicationBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ApplicationBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ApplicationBasic::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ApplicationBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationBasic::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ApplicationBasicAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ApplicationBasicAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRApplicationBasicAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ApplicationBasic::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ApplicationBasicAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationBasic::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ApplicationBasic::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterAccountLogin

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)getSetupPINWithParams:(MTRAccountLoginClusterGetSetupPINParams *)params
                   completion:(void (^)(MTRAccountLoginClusterGetSetupPINResponseParams * _Nullable data,
                                  NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)loginWithParams:(MTRAccountLoginClusterLoginParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)logoutWithCompletion:(MTRStatusCompletion)completion
{
    [self logoutWithParams:nil completion:completion];
}
- (void)logoutWithParams:(MTRAccountLoginClusterLogoutParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccountLogin::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<AccountLoginGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccountLogin::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<AccountLoginGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = AccountLogin::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<AccountLoginGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccountLogin::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<AccountLoginAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccountLogin::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<AccountLoginAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = AccountLogin::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<AccountLoginAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccountLoginAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccountLogin::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<AccountLoginAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccountLogin::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<AccountLoginAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRAccountLoginAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AccountLogin::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<AccountLoginAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccountLogin::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccountLogin::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AccountLogin::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterElectricalMeasurement

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)getProfileInfoCommandWithCompletion:(MTRStatusCompletion)completion
{
    [self getProfileInfoCommandWithParams:nil completion:completion];
}
- (void)getProfileInfoCommandWithParams:(MTRElectricalMeasurementClusterGetProfileInfoCommandParams * _Nullable)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)getMeasurementProfileCommandWithParams:(MTRElectricalMeasurementClusterGetMeasurementProfileCommandParams *)params
                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)readAttributeMeasurementTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasurementTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasurementTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltage::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltage::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltage::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcVoltageMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMin::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcVoltageMinWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMin::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcVoltageMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMin::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcVoltageMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMax::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcVoltageMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMax::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcVoltageMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMax::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcCurrentMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMin::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcCurrentMinWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMin::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcCurrentMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMin::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcCurrentMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMax::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcCurrentMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMax::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcCurrentMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMax::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcPower::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcPower::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcPower::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcPowerMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMin::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcPowerMinWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMin::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcPowerMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMin::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcPowerMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMax::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcPowerMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMax::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcPowerMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMax::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcVoltageMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcVoltageMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcVoltageMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMultiplier::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcVoltageDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcVoltageDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcVoltageDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageDivisor::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcCurrentMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcCurrentMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcCurrentMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMultiplier::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcCurrentDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcCurrentDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcCurrentDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentDivisor::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcPowerMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcPowerMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcPowerMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMultiplier::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcPowerDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeDcPowerDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeDcPowerDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerDivisor::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequency::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequency::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcFrequencyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequency::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcFrequencyMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMin::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcFrequencyMinWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMin::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcFrequencyMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMin::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcFrequencyMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMax::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcFrequencyMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMax::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcFrequencyMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMax::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNeutralCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::NeutralCurrent::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeNeutralCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::NeutralCurrent::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNeutralCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::NeutralCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTotalActivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo;
            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTotalActivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo;
            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTotalActivePowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTotalReactivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::TotalReactivePower::TypeInfo;
            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTotalReactivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::TotalReactivePower::TypeInfo;
            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTotalReactivePowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::TotalReactivePower::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTotalApparentPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::TotalApparentPower::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeTotalApparentPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::TotalApparentPower::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTotalApparentPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::TotalApparentPower::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasured1stHarmonicCurrentWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::Measured1stHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasured1stHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::Measured1stHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasured1stHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::Measured1stHarmonicCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasured3rdHarmonicCurrentWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::Measured3rdHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasured3rdHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::Measured3rdHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasured3rdHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::Measured3rdHarmonicCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasured5thHarmonicCurrentWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::Measured5thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasured5thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::Measured5thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasured5thHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::Measured5thHarmonicCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasured7thHarmonicCurrentWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::Measured7thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasured7thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::Measured7thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasured7thHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::Measured7thHarmonicCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasured9thHarmonicCurrentWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::Measured9thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasured9thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::Measured9thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasured9thHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::Measured9thHarmonicCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasured11thHarmonicCurrentWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::Measured11thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasured11thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::Measured11thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasured11thHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                             endpoint:(NSNumber *)endpoint
                                                                queue:(dispatch_queue_t)queue
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::Measured11thHarmonicCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasuredPhase1stHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasuredPhase1stHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasuredPhase1stHarmonicCurrentWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasuredPhase3rdHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasuredPhase3rdHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasuredPhase3rdHarmonicCurrentWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasuredPhase5thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasuredPhase5thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasuredPhase5thHarmonicCurrentWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasuredPhase7thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasuredPhase7thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasuredPhase7thHarmonicCurrentWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasuredPhase9thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasuredPhase9thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasuredPhase9thHarmonicCurrentWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasuredPhase11thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeMeasuredPhase11thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeMeasuredPhase11thHarmonicCurrentWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcFrequencyMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcFrequencyMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcFrequencyMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMultiplier::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcFrequencyDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcFrequencyDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcFrequencyDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyDivisor::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePowerMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::PowerMultiplier::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePowerMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::PowerMultiplier::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePowerMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::PowerMultiplier::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePowerDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::PowerDivisor::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePowerDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::PowerDivisor::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePowerDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::PowerDivisor::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeHarmonicCurrentMultiplierWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::HarmonicCurrentMultiplier::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeHarmonicCurrentMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::HarmonicCurrentMultiplier::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeHarmonicCurrentMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::HarmonicCurrentMultiplier::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhaseHarmonicCurrentMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePhaseHarmonicCurrentMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                     reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePhaseHarmonicCurrentMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                endpoint:(NSNumber *)endpoint
                                                                   queue:(dispatch_queue_t)queue
                                                              completion:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstantaneousVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousVoltage::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeInstantaneousVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousVoltage::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInstantaneousVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousVoltage::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstantaneousLineCurrentWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousLineCurrent::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeInstantaneousLineCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousLineCurrent::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInstantaneousLineCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousLineCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstantaneousActiveCurrentWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousActiveCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeInstantaneousActiveCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousActiveCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInstantaneousActiveCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousActiveCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstantaneousReactiveCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousReactiveCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeInstantaneousReactiveCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousReactiveCurrent::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInstantaneousReactiveCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousReactiveCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstantaneousPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousPower::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeInstantaneousPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousPower::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInstantaneousPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousPower::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltageMinWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltageMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsCurrentMinWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsCurrentMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsCurrentMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsCurrentMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActivePowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActivePowerMinWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActivePowerMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActivePowerMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActivePowerMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReactivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePower::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeReactivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePower::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeReactivePowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePower::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeApparentPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPower::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeApparentPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPower::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeApparentPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPower::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePowerFactorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactor::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePowerFactorWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactor::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePowerFactorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactor::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAverageRmsVoltageMeasurementPeriodWithValue:(NSNumber * _Nonnull)value
                                                       completion:(MTRStatusCompletion)completion
{
    [self writeAttributeAverageRmsVoltageMeasurementPeriodWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeAverageRmsVoltageMeasurementPeriodWithValue:(NSNumber * _Nonnull)value
                                                           params:(MTRWriteParams * _Nullable)params
                                                       completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodWithParams:(MTRSubscribeParams * _Nonnull)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAverageRmsVoltageMeasurementPeriodWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                    endpoint:(NSNumber *)endpoint
                                                                       queue:(dispatch_queue_t)queue
                                                                  completion:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsUnderVoltageCounterWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAverageRmsUnderVoltageCounterWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeAverageRmsUnderVoltageCounterWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeAverageRmsUnderVoltageCounterWithValue:(NSNumber * _Nonnull)value
                                                      params:(MTRWriteParams * _Nullable)params
                                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeAverageRmsUnderVoltageCounterWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAverageRmsUnderVoltageCounterWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeOverVoltagePeriodWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsExtremeOverVoltagePeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeRmsExtremeOverVoltagePeriodWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeRmsExtremeOverVoltagePeriodWithValue:(NSNumber * _Nonnull)value
                                                    params:(MTRWriteParams * _Nullable)params
                                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeRmsExtremeOverVoltagePeriodWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsExtremeOverVoltagePeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                             endpoint:(NSNumber *)endpoint
                                                                queue:(dispatch_queue_t)queue
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsExtremeUnderVoltagePeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeRmsExtremeUnderVoltagePeriodWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeRmsExtremeUnderVoltagePeriodWithValue:(NSNumber * _Nonnull)value
                                                     params:(MTRWriteParams * _Nullable)params
                                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeRmsExtremeUnderVoltagePeriodWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsExtremeUnderVoltagePeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSagPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageSagPeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeRmsVoltageSagPeriodWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeRmsVoltageSagPeriodWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeRmsVoltageSagPeriodWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageSagPeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSwellPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageSwellPeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeRmsVoltageSwellPeriodWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeRmsVoltageSwellPeriodWithValue:(NSNumber * _Nonnull)value
                                              params:(MTRWriteParams * _Nullable)params
                                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeRmsVoltageSwellPeriodWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageSwellPeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcVoltageMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcVoltageMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcVoltageMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageMultiplier::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcVoltageDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcVoltageDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcVoltageDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageDivisor::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcCurrentMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcCurrentMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcCurrentMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentMultiplier::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcCurrentDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcCurrentDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcCurrentDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentDivisor::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcPowerMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcPowerMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcPowerMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcPowerMultiplier::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcPowerMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcPowerMultiplier::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcPowerDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcPowerDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcPowerDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcPowerDivisor::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcPowerDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcPowerDivisor::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOverloadAlarmsMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value
                                           params:(MTRWriteParams * _Nullable)params
                                       completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOverloadAlarmsMaskWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOverloadAlarmsMaskWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeVoltageOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::VoltageOverload::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeVoltageOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::VoltageOverload::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeVoltageOverloadWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::VoltageOverload::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::CurrentOverload::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeCurrentOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::CurrentOverload::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCurrentOverloadWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::CurrentOverload::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcOverloadAlarmsMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeAcOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeAcOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeAcOverloadAlarmsMaskWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcOverloadAlarmsMaskWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcVoltageOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageOverload::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcVoltageOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageOverload::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcVoltageOverloadWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageOverload::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcCurrentOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentOverload::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcCurrentOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentOverload::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcCurrentOverloadWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentOverload::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcActivePowerOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcActivePowerOverload::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcActivePowerOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcActivePowerOverload::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcActivePowerOverloadWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcActivePowerOverload::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcReactivePowerOverloadWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcReactivePowerOverload::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcReactivePowerOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcReactivePowerOverload::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcReactivePowerOverloadWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AcReactivePowerOverload::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsOverVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltage::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAverageRmsOverVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltage::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAverageRmsOverVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltage::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsUnderVoltageWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltage::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAverageRmsUnderVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltage::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAverageRmsUnderVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltage::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeOverVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltage::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsExtremeOverVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltage::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsExtremeOverVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltage::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeUnderVoltageWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltage::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsExtremeUnderVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltage::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsExtremeUnderVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltage::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSagWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSag::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltageSagWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSag::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageSagWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSag::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSwellWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwell::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltageSwellWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwell::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageSwellWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwell::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLineCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLineCurrentPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLineCurrentPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseB::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActiveCurrentPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseB::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActiveCurrentPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReactiveCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseB::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeReactiveCurrentPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseB::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeReactiveCurrentPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltagePhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltagePhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltagePhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageMinPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltageMinPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageMinPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageMaxPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltageMaxPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageMaxPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsCurrentPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsCurrentPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentMinPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsCurrentMinPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsCurrentMinPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentMaxPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsCurrentMaxPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsCurrentMaxPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseB::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActivePowerPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseB::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActivePowerPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerMinPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseB::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActivePowerMinPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseB::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActivePowerMinPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerMaxPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseB::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActivePowerMaxPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseB::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActivePowerMaxPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReactivePowerPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseB::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeReactivePowerPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseB::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeReactivePowerPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeApparentPowerPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeApparentPowerPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeApparentPowerPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePowerFactorPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseB::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePowerFactorPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseB::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePowerFactorPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                                     subscriptionEstablished:
                                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                               reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                          endpoint:(NSNumber *)endpoint
                                                                             queue:(dispatch_queue_t)queue
                                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                                       NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsOverVoltageCounterPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAverageRmsOverVoltageCounterPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAverageRmsOverVoltageCounterPhaseBWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                    endpoint:(NSNumber *)endpoint
                                                                       queue:(dispatch_queue_t)queue
                                                                  completion:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsUnderVoltageCounterPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAverageRmsUnderVoltageCounterPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                                subscriptionEstablished:
                                                    (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                          reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAverageRmsUnderVoltageCounterPhaseBWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                     endpoint:(NSNumber *)endpoint
                                                                        queue:(dispatch_queue_t)queue
                                                                   completion:(void (^)(NSNumber * _Nullable value,
                                                                                  NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsExtremeOverVoltagePeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                   endpoint:(NSNumber *)endpoint
                                                                      queue:(dispatch_queue_t)queue
                                                                 completion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsExtremeUnderVoltagePeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                    endpoint:(NSNumber *)endpoint
                                                                       queue:(dispatch_queue_t)queue
                                                                  completion:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSagPeriodPhaseBWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltageSagPeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageSagPeriodPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSwellPeriodPhaseBWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltageSwellPeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageSwellPeriodPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                             endpoint:(NSNumber *)endpoint
                                                                queue:(dispatch_queue_t)queue
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLineCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeLineCurrentPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLineCurrentPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseC::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActiveCurrentPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseC::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActiveCurrentPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReactiveCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseC::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeReactiveCurrentPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseC::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeReactiveCurrentPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltagePhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltagePhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltagePhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageMinPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltageMinPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageMinPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageMaxPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltageMaxPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageMaxPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsCurrentPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsCurrentPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentMinPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsCurrentMinPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsCurrentMinPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentMaxPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsCurrentMaxPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsCurrentMaxPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseC::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActivePowerPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseC::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActivePowerPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerMinPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseC::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActivePowerMinPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseC::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActivePowerMinPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerMaxPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseC::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeActivePowerMaxPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseC::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeActivePowerMaxPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReactivePowerPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseC::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeReactivePowerPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseC::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeReactivePowerPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeApparentPowerPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeApparentPowerPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeApparentPowerPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePowerFactorPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseC::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributePowerFactorPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseC::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributePowerFactorPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                                     subscriptionEstablished:
                                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                               reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                          endpoint:(NSNumber *)endpoint
                                                                             queue:(dispatch_queue_t)queue
                                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                                       NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsOverVoltageCounterPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAverageRmsOverVoltageCounterPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAverageRmsOverVoltageCounterPhaseCWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                    endpoint:(NSNumber *)endpoint
                                                                       queue:(dispatch_queue_t)queue
                                                                  completion:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsUnderVoltageCounterPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAverageRmsUnderVoltageCounterPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                                subscriptionEstablished:
                                                    (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                          reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAverageRmsUnderVoltageCounterPhaseCWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                     endpoint:(NSNumber *)endpoint
                                                                        queue:(dispatch_queue_t)queue
                                                                   completion:(void (^)(NSNumber * _Nullable value,
                                                                                  NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsExtremeOverVoltagePeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                   endpoint:(NSNumber *)endpoint
                                                                      queue:(dispatch_queue_t)queue
                                                                 completion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsExtremeUnderVoltagePeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                    endpoint:(NSNumber *)endpoint
                                                                       queue:(dispatch_queue_t)queue
                                                                  completion:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSagPeriodPhaseCWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltageSagPeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageSagPeriodPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSwellPeriodPhaseCWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeRmsVoltageSwellPeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRmsVoltageSwellPeriodPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                             endpoint:(NSNumber *)endpoint
                                                                queue:(dispatch_queue_t)queue
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ElectricalMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<ElectricalMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ElectricalMeasurement::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ElectricalMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ElectricalMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<ElectricalMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ElectricalMeasurement::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ElectricalMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ElectricalMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<ElectricalMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<ElectricalMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterTestCluster

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

        _device = device;
        _endpoint = [endpoint unsignedShortValue];
    }
    return self;
}

- (void)testWithCompletion:(MTRStatusCompletion)completion
{
    [self testWithParams:nil completion:completion];
}
- (void)testWithParams:(MTRTestClusterClusterTestParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)testNotHandledWithCompletion:(MTRStatusCompletion)completion
{
    [self testNotHandledWithParams:nil completion:completion];
}
- (void)testNotHandledWithParams:(MTRTestClusterClusterTestNotHandledParams * _Nullable)params
                      completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)testSpecificWithCompletion:(void (^)(MTRTestClusterClusterTestSpecificResponseParams * _Nullable data,
                                       NSError * _Nullable error))completion
{
    [self testSpecificWithParams:nil completion:completion];
}
- (void)testSpecificWithParams:(MTRTestClusterClusterTestSpecificParams * _Nullable)params
                    completion:(void (^)(MTRTestClusterClusterTestSpecificResponseParams * _Nullable data,
                                   NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterTestSpecificResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)testUnknownCommandWithCompletion:(MTRStatusCompletion)completion
{
    [self testUnknownCommandWithParams:nil completion:completion];
}
- (void)testUnknownCommandWithParams:(MTRTestClusterClusterTestUnknownCommandParams * _Nullable)params
                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)testAddArgumentsWithParams:(MTRTestClusterClusterTestAddArgumentsParams *)params
                        completion:(void (^)(MTRTestClusterClusterTestAddArgumentsResponseParams * _Nullable data,
                                       NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)testSimpleArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleArgumentRequestParams *)params
                                 completion:(void (^)(MTRTestClusterClusterTestSimpleArgumentResponseParams * _Nullable data,
                                                NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)testStructArrayArgumentRequestWithParams:(MTRTestClusterClusterTestStructArrayArgumentRequestParams *)params
                                      completion:
                                          (void (^)(MTRTestClusterClusterTestStructArrayArgumentResponseParams * _Nullable data,
                                              NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)testStructArgumentRequestWithParams:(MTRTestClusterClusterTestStructArgumentRequestParams *)params
                                 completion:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)testNestedStructArgumentRequestWithParams:(MTRTestClusterClusterTestNestedStructArgumentRequestParams *)params
                                       completion:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                      NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)testListStructArgumentRequestWithParams:(MTRTestClusterClusterTestListStructArgumentRequestParams *)params
                                     completion:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                    NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)testListInt8UArgumentRequestWithParams:(MTRTestClusterClusterTestListInt8UArgumentRequestParams *)params
                                    completion:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                   NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)testNestedStructListArgumentRequestWithParams:(MTRTestClusterClusterTestNestedStructListArgumentRequestParams *)params
                                           completion:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                          NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)testListNestedStructListArgumentRequestWithParams:
            (MTRTestClusterClusterTestListNestedStructListArgumentRequestParams *)params
                                               completion:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                              NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)testListInt8UReverseRequestWithParams:(MTRTestClusterClusterTestListInt8UReverseRequestParams *)params
                                   completion:(void (^)(MTRTestClusterClusterTestListInt8UReverseResponseParams * _Nullable data,
                                                  NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)testEnumsRequestWithParams:(MTRTestClusterClusterTestEnumsRequestParams *)params
                        completion:(void (^)(MTRTestClusterClusterTestEnumsResponseParams * _Nullable data,
                                       NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterTestEnumsResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)testNullableOptionalRequestWithParams:(MTRTestClusterClusterTestNullableOptionalRequestParams * _Nullable)params
                                   completion:(void (^)(MTRTestClusterClusterTestNullableOptionalResponseParams * _Nullable data,
                                                  NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)testComplexNullableOptionalRequestWithParams:(MTRTestClusterClusterTestComplexNullableOptionalRequestParams *)params
                                          completion:
                                              (void (^)(
                                                  MTRTestClusterClusterTestComplexNullableOptionalResponseParams * _Nullable data,
                                                  NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)simpleStructEchoRequestWithParams:(MTRTestClusterClusterSimpleStructEchoRequestParams *)params
                               completion:(void (^)(MTRTestClusterClusterSimpleStructResponseParams * _Nullable data,
                                              NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterSimpleStructResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)timedInvokeRequestWithCompletion:(MTRStatusCompletion)completion
{
    [self timedInvokeRequestWithParams:nil completion:completion];
}
- (void)timedInvokeRequestWithParams:(MTRTestClusterClusterTimedInvokeRequestParams * _Nullable)params
                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)testSimpleOptionalArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleOptionalArgumentRequestParams * _Nullable)params
                                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCommandSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(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);
        });
}

- (void)testEmitTestEventRequestWithParams:(MTRTestClusterClusterTestEmitTestEventRequestParams *)params
                                completion:(void (^)(MTRTestClusterClusterTestEmitTestEventResponseParams * _Nullable data,
                                               NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)
    testEmitTestFabricScopedEventRequestWithParams:(MTRTestClusterClusterTestEmitTestFabricScopedEventRequestParams *)params
                                        completion:
                                            (void (^)(
                                                MTRTestClusterClusterTestEmitTestFabricScopedEventResponseParams * _Nullable data,
                                                NSError * _Nullable error))completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(self.callbackQueue, self.device, completion,
        ^(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);
        });
}

- (void)readAttributeBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Boolean::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBooleanWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBooleanWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeBooleanWithValue:(NSNumber * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Boolean::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBooleanWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Boolean::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBooleanWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Boolean::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBitmap8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterBitmap8AttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo;
            auto successFn = Callback<TestClusterBitmap8AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBitmap8WithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBitmap8WithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeBitmap8WithValue:(NSNumber * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBitmap8WithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo;
            auto successFn = Callback<TestClusterBitmap8AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBitmap8WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterBitmap8AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterBitmap8AttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBitmap16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterBitmap16AttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo;
            auto successFn = Callback<TestClusterBitmap16AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBitmap16WithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBitmap16WithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeBitmap16WithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBitmap16WithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo;
            auto successFn = Callback<TestClusterBitmap16AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBitmap16WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterBitmap16AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterBitmap16AttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBitmap32WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterBitmap32AttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo;
            auto successFn = Callback<TestClusterBitmap32AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBitmap32WithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBitmap32WithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeBitmap32WithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedIntValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBitmap32WithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo;
            auto successFn = Callback<TestClusterBitmap32AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBitmap32WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterBitmap32AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterBitmap32AttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBitmap64WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterBitmap64AttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo;
            auto successFn = Callback<TestClusterBitmap64AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBitmap64WithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeBitmap64WithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeBitmap64WithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedLongLongValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeBitmap64WithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo;
            auto successFn = Callback<TestClusterBitmap64AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeBitmap64WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterBitmap64AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterBitmap64AttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int8u::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt8uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt8uWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt8uWithValue:(NSNumber * _Nonnull)value
                              params:(MTRWriteParams * _Nullable)params
                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int8u::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int8u::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt8uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int8u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt16uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int16u::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt16uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt16uWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt16uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int16u::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt16uWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int16u::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt16uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int16u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt24uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt24uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt24uWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt24uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt24uWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt24uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt32uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt32uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt32uWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt32uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt32uWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt32uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt40uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt40uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt40uWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt40uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt40uWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt40uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt48uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt48uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt48uWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt48uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt48uWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt48uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt56uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt56uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt56uWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt56uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt56uWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt56uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt64uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt64uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt64uWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt64uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt64uWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt64uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt8sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt8sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt8sWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt8sWithValue:(NSNumber * _Nonnull)value
                              params:(MTRWriteParams * _Nullable)params
                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.charValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt8sWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt8sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt16sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt16sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt16sWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt16sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt16sWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt16sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt24sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo;
            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt24sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt24sWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt24sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.intValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt24sWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo;
            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt24sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt32sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo;
            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt32sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt32sWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt32sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.intValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt32sWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo;
            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt32sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt40sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo;
            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt40sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt40sWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt40sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.longLongValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt40sWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo;
            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt40sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt48sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo;
            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt48sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt48sWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt48sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.longLongValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt48sWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo;
            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt48sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt56sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo;
            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt56sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt56sWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt56sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.longLongValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt56sWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo;
            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt56sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt64sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo;
            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInt64sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeInt64sWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeInt64sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.longLongValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeInt64sWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo;
            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeInt64sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnum8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEnum8WithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeEnum8WithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeEnum8WithValue:(NSNumber * _Nonnull)value
                              params:(MTRWriteParams * _Nullable)params
                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeEnum8WithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEnum8WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnum16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEnum16WithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeEnum16WithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeEnum16WithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeEnum16WithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEnum16WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFloatSingleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFloatAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo;
            auto successFn = Callback<FloatAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFloatSingleWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeFloatSingleWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeFloatSingleWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.floatValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeFloatSingleWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRFloatAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo;
            auto successFn = Callback<FloatAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFloatSingleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRFloatAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<FloatAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFloatDoubleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoubleAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo;
            auto successFn = Callback<DoubleAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFloatDoubleWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeFloatDoubleWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeFloatDoubleWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.doubleValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeFloatDoubleWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRDoubleAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo;
            auto successFn = Callback<DoubleAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoubleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFloatDoubleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRDoubleAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<DoubleAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOctetStringWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTROctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo;
            auto successFn = Callback<OctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOctetStringWithValue:(NSData * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeOctetStringWithValue:(NSData * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeOctetStringWithValue:(NSData * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asByteSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeOctetStringWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo;
            auto successFn = Callback<OctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeOctetStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTROctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<OctetStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeListInt8uWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterListInt8uListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo;
            auto successFn = Callback<TestClusterListInt8uListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeListInt8uWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeListInt8uWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeListInt8uWithValue:(NSArray * _Nonnull)value
                                  params:(MTRWriteParams * _Nullable)params
                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.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 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[NSNumber class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (NSNumber *) value[i_0];
                        listHolder_0->mList[i_0] = element_0.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeListInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo;
            auto successFn = Callback<TestClusterListInt8uListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeListInt8uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterListInt8uListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterListInt8uListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeListOctetStringWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterListOctetStringListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo;
            auto successFn = Callback<TestClusterListOctetStringListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeListOctetStringWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeListOctetStringWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeListOctetStringWithValue:(NSArray * _Nonnull)value
                                        params:(MTRWriteParams * _Nullable)params
                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.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 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[NSData class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (NSData *) value[i_0];
                        listHolder_0->mList[i_0] = [self asByteSpan:element_0];
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeListOctetStringWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo;
            auto successFn = Callback<TestClusterListOctetStringListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeListOctetStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterListOctetStringListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterListOctetStringListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeListStructOctetStringWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterListStructOctetStringListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo;
            auto successFn = Callback<TestClusterListStructOctetStringListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeListStructOctetStringWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeListStructOctetStringWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeListStructOctetStringWithValue:(NSArray * _Nonnull)value
                                              params:(MTRWriteParams * _Nullable)params
                                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.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 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[MTRTestClusterClusterTestListStructOctet class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (MTRTestClusterClusterTestListStructOctet *) value[i_0];
                        listHolder_0->mList[i_0].member1 = element_0.member1.unsignedLongLongValue;
                        listHolder_0->mList[i_0].member2 = [self asByteSpan:element_0.member2];
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeListStructOctetStringWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo;
            auto successFn = Callback<TestClusterListStructOctetStringListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeListStructOctetStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterListStructOctetStringListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TestClusterListStructOctetStringListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeLongOctetStringWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTROctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo;
            auto successFn = Callback<OctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLongOctetStringWithValue:(NSData * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLongOctetStringWithValue:(NSData * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeLongOctetStringWithValue:(NSData * _Nonnull)value
                                        params:(MTRWriteParams * _Nullable)params
                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asByteSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLongOctetStringWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTROctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo;
            auto successFn = Callback<OctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLongOctetStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTROctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<OctetStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCharStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::CharString::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCharStringWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeCharStringWithValue:(NSString * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeCharStringWithValue:(NSString * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::CharString::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeCharStringWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::CharString::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeCharStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::CharString::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLongCharStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLongCharStringWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLongCharStringWithValue:(NSString * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeLongCharStringWithValue:(NSString * _Nonnull)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeLongCharStringWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo;
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeLongCharStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEpochUsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEpochUsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeEpochUsWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeEpochUsWithValue:(NSNumber * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeEpochUsWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo;
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEpochUsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEpochSWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEpochSWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeEpochSWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeEpochSWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeEpochSWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEpochSWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeVendorIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo;
            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeVendorIdWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeVendorIdWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeVendorIdWithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeVendorIdWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRVendorIdAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo;
            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeVendorIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeListNullablesAndOptionalsStructWithCompletion:(void (^)(NSArray * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
            auto successFn = Callback<TestClusterListNullablesAndOptionalsStructListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeListNullablesAndOptionalsStructWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeListNullablesAndOptionalsStructWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeListNullablesAndOptionalsStructWithValue:(NSArray * _Nonnull)value
                                                        params:(MTRWriteParams * _Nullable)params
                                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.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 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[MTRTestClusterClusterNullablesAndOptionalsStruct class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (MTRTestClusterClusterNullablesAndOptionalsStruct *) value[i_0];
                        if (element_0.nullableInt == nil) {
                            listHolder_0->mList[i_0].nullableInt.SetNull();
                        } else {
                            auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableInt.SetNonNull();
                            nonNullValue_2 = element_0.nullableInt.unsignedShortValue;
                        }
                        if (element_0.optionalInt != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].optionalInt.Emplace();
                            definedValue_2 = element_0.optionalInt.unsignedShortValue;
                        }
                        if (element_0.nullableOptionalInt != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalInt.Emplace();
                            if (element_0.nullableOptionalInt == nil) {
                                definedValue_2.SetNull();
                            } else {
                                auto & nonNullValue_3 = definedValue_2.SetNonNull();
                                nonNullValue_3 = element_0.nullableOptionalInt.unsignedShortValue;
                            }
                        }
                        if (element_0.nullableString == nil) {
                            listHolder_0->mList[i_0].nullableString.SetNull();
                        } else {
                            auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableString.SetNonNull();
                            nonNullValue_2 = [self asCharSpan:element_0.nullableString];
                        }
                        if (element_0.optionalString != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].optionalString.Emplace();
                            definedValue_2 = [self asCharSpan:element_0.optionalString];
                        }
                        if (element_0.nullableOptionalString != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalString.Emplace();
                            if (element_0.nullableOptionalString == nil) {
                                definedValue_2.SetNull();
                            } else {
                                auto & nonNullValue_3 = definedValue_2.SetNonNull();
                                nonNullValue_3 = [self asCharSpan:element_0.nullableOptionalString];
                            }
                        }
                        if (element_0.nullableStruct == nil) {
                            listHolder_0->mList[i_0].nullableStruct.SetNull();
                        } else {
                            auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableStruct.SetNonNull();
                            nonNullValue_2.a = element_0.nullableStruct.a.unsignedCharValue;
                            nonNullValue_2.b = element_0.nullableStruct.b.boolValue;
                            nonNullValue_2.c = static_cast<std::remove_reference_t<decltype(nonNullValue_2.c)>>(
                                element_0.nullableStruct.c.unsignedCharValue);
                            nonNullValue_2.d = [self asByteSpan:element_0.nullableStruct.d];
                            nonNullValue_2.e = [self asCharSpan:element_0.nullableStruct.e];
                            nonNullValue_2.f = static_cast<std::remove_reference_t<decltype(nonNullValue_2.f)>>(
                                element_0.nullableStruct.f.unsignedCharValue);
                            nonNullValue_2.g = element_0.nullableStruct.g.floatValue;
                            nonNullValue_2.h = element_0.nullableStruct.h.doubleValue;
                        }
                        if (element_0.optionalStruct != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].optionalStruct.Emplace();
                            definedValue_2.a = element_0.optionalStruct.a.unsignedCharValue;
                            definedValue_2.b = element_0.optionalStruct.b.boolValue;
                            definedValue_2.c = static_cast<std::remove_reference_t<decltype(definedValue_2.c)>>(
                                element_0.optionalStruct.c.unsignedCharValue);
                            definedValue_2.d = [self asByteSpan:element_0.optionalStruct.d];
                            definedValue_2.e = [self asCharSpan:element_0.optionalStruct.e];
                            definedValue_2.f = static_cast<std::remove_reference_t<decltype(definedValue_2.f)>>(
                                element_0.optionalStruct.f.unsignedCharValue);
                            definedValue_2.g = element_0.optionalStruct.g.floatValue;
                            definedValue_2.h = element_0.optionalStruct.h.doubleValue;
                        }
                        if (element_0.nullableOptionalStruct != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalStruct.Emplace();
                            if (element_0.nullableOptionalStruct == nil) {
                                definedValue_2.SetNull();
                            } else {
                                auto & nonNullValue_3 = definedValue_2.SetNonNull();
                                nonNullValue_3.a = element_0.nullableOptionalStruct.a.unsignedCharValue;
                                nonNullValue_3.b = element_0.nullableOptionalStruct.b.boolValue;
                                nonNullValue_3.c = static_cast<std::remove_reference_t<decltype(nonNullValue_3.c)>>(
                                    element_0.nullableOptionalStruct.c.unsignedCharValue);
                                nonNullValue_3.d = [self asByteSpan:element_0.nullableOptionalStruct.d];
                                nonNullValue_3.e = [self asCharSpan:element_0.nullableOptionalStruct.e];
                                nonNullValue_3.f = static_cast<std::remove_reference_t<decltype(nonNullValue_3.f)>>(
                                    element_0.nullableOptionalStruct.f.unsignedCharValue);
                                nonNullValue_3.g = element_0.nullableOptionalStruct.g.floatValue;
                                nonNullValue_3.h = element_0.nullableOptionalStruct.h.doubleValue;
                            }
                        }
                        if (element_0.nullableList == nil) {
                            listHolder_0->mList[i_0].nullableList.SetNull();
                        } else {
                            auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableList.SetNonNull();
                            {
                                using ListType_3 = std::remove_reference_t<decltype(nonNullValue_2)>;
                                using ListMemberType_3 = ListMemberTypeGetter<ListType_3>::Type;
                                if (element_0.nullableList.count != 0) {
                                    auto * listHolder_3 = new ListHolder<ListMemberType_3>(element_0.nullableList.count);
                                    if (listHolder_3 == nullptr || listHolder_3->mList == nullptr) {
                                        return CHIP_ERROR_INVALID_ARGUMENT;
                                    }
                                    listFreer.add(listHolder_3);
                                    for (size_t i_3 = 0; i_3 < element_0.nullableList.count; ++i_3) {
                                        if (![element_0.nullableList[i_3] isKindOfClass:[NSNumber class]]) {
                                            // Wrong kind of value.
                                            return CHIP_ERROR_INVALID_ARGUMENT;
                                        }
                                        auto element_3 = (NSNumber *) element_0.nullableList[i_3];
                                        listHolder_3->mList[i_3]
                                            = static_cast<std::remove_reference_t<decltype(listHolder_3->mList[i_3])>>(
                                                element_3.unsignedCharValue);
                                    }
                                    nonNullValue_2 = ListType_3(listHolder_3->mList, element_0.nullableList.count);
                                } else {
                                    nonNullValue_2 = ListType_3();
                                }
                            }
                        }
                        if (element_0.optionalList != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].optionalList.Emplace();
                            {
                                using ListType_3 = std::remove_reference_t<decltype(definedValue_2)>;
                                using ListMemberType_3 = ListMemberTypeGetter<ListType_3>::Type;
                                if (element_0.optionalList.count != 0) {
                                    auto * listHolder_3 = new ListHolder<ListMemberType_3>(element_0.optionalList.count);
                                    if (listHolder_3 == nullptr || listHolder_3->mList == nullptr) {
                                        return CHIP_ERROR_INVALID_ARGUMENT;
                                    }
                                    listFreer.add(listHolder_3);
                                    for (size_t i_3 = 0; i_3 < element_0.optionalList.count; ++i_3) {
                                        if (![element_0.optionalList[i_3] isKindOfClass:[NSNumber class]]) {
                                            // Wrong kind of value.
                                            return CHIP_ERROR_INVALID_ARGUMENT;
                                        }
                                        auto element_3 = (NSNumber *) element_0.optionalList[i_3];
                                        listHolder_3->mList[i_3]
                                            = static_cast<std::remove_reference_t<decltype(listHolder_3->mList[i_3])>>(
                                                element_3.unsignedCharValue);
                                    }
                                    definedValue_2 = ListType_3(listHolder_3->mList, element_0.optionalList.count);
                                } else {
                                    definedValue_2 = ListType_3();
                                }
                            }
                        }
                        if (element_0.nullableOptionalList != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalList.Emplace();
                            if (element_0.nullableOptionalList == nil) {
                                definedValue_2.SetNull();
                            } else {
                                auto & nonNullValue_3 = definedValue_2.SetNonNull();
                                {
                                    using ListType_4 = std::remove_reference_t<decltype(nonNullValue_3)>;
                                    using ListMemberType_4 = ListMemberTypeGetter<ListType_4>::Type;
                                    if (element_0.nullableOptionalList.count != 0) {
                                        auto * listHolder_4
                                            = new ListHolder<ListMemberType_4>(element_0.nullableOptionalList.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_0.nullableOptionalList.count; ++i_4) {
                                            if (![element_0.nullableOptionalList[i_4] isKindOfClass:[NSNumber class]]) {
                                                // Wrong kind of value.
                                                return CHIP_ERROR_INVALID_ARGUMENT;
                                            }
                                            auto element_4 = (NSNumber *) element_0.nullableOptionalList[i_4];
                                            listHolder_4->mList[i_4]
                                                = static_cast<std::remove_reference_t<decltype(listHolder_4->mList[i_4])>>(
                                                    element_4.unsignedCharValue);
                                        }
                                        nonNullValue_3 = ListType_4(listHolder_4->mList, element_0.nullableOptionalList.count);
                                    } else {
                                        nonNullValue_3 = ListType_4();
                                    }
                                }
                            }
                        }
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeListNullablesAndOptionalsStructWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSArray * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
            auto successFn = Callback<TestClusterListNullablesAndOptionalsStructListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeListNullablesAndOptionalsStructWithClusterStateCache:
            (MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSArray * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TestClusterListNullablesAndOptionalsStructListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeEnumAttrWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::EnumAttr::TypeInfo;
            auto successFn = Callback<TestClusterClusterSimpleEnumAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEnumAttrWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeEnumAttrWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeEnumAttrWithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::EnumAttr::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeEnumAttrWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::EnumAttr::TypeInfo;
            auto successFn = Callback<TestClusterClusterSimpleEnumAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeEnumAttrWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::EnumAttr::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterClusterSimpleEnumAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStructAttrWithCompletion:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                  NSError * _Nullable error))completion
{
    new MTRTestClusterStructAttrStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::StructAttr::TypeInfo;
            auto successFn = Callback<TestClusterStructAttrStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeStructAttrWithValue:(MTRTestClusterClusterSimpleStruct * _Nonnull)value
                               completion:(MTRStatusCompletion)completion
{
    [self writeAttributeStructAttrWithValue:(MTRTestClusterClusterSimpleStruct * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeStructAttrWithValue:(MTRTestClusterClusterSimpleStruct * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::StructAttr::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue.a = value.a.unsignedCharValue;
            cppValue.b = value.b.boolValue;
            cppValue.c = static_cast<std::remove_reference_t<decltype(cppValue.c)>>(value.c.unsignedCharValue);
            cppValue.d = [self asByteSpan:value.d];
            cppValue.e = [self asCharSpan:value.e];
            cppValue.f = static_cast<std::remove_reference_t<decltype(cppValue.f)>>(value.f.unsignedCharValue);
            cppValue.g = value.g.floatValue;
            cppValue.h = value.h.doubleValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeStructAttrWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                   NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::StructAttr::TypeInfo;
            auto successFn = Callback<TestClusterStructAttrStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeStructAttrWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                         NSError * _Nullable error))completion
{
    new MTRTestClusterStructAttrStructAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::StructAttr::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterStructAttrStructAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRangeRestrictedInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRangeRestrictedInt8uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeRangeRestrictedInt8uWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeRangeRestrictedInt8uWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeRangeRestrictedInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRangeRestrictedInt8uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRangeRestrictedInt8sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRangeRestrictedInt8sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeRangeRestrictedInt8sWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeRangeRestrictedInt8sWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.charValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeRangeRestrictedInt8sWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo;
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRangeRestrictedInt8sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRangeRestrictedInt16uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRangeRestrictedInt16uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeRangeRestrictedInt16uWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeRangeRestrictedInt16uWithValue:(NSNumber * _Nonnull)value
                                              params:(MTRWriteParams * _Nullable)params
                                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeRangeRestrictedInt16uWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRangeRestrictedInt16uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRangeRestrictedInt16sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRangeRestrictedInt16sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeRangeRestrictedInt16sWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeRangeRestrictedInt16sWithValue:(NSNumber * _Nonnull)value
                                              params:(MTRWriteParams * _Nullable)params
                                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeRangeRestrictedInt16sWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo;
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeRangeRestrictedInt16sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeListLongOctetStringWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterListLongOctetStringListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::ListLongOctetString::TypeInfo;
            auto successFn = Callback<TestClusterListLongOctetStringListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeListLongOctetStringWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeListLongOctetStringWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeListLongOctetStringWithValue:(NSArray * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::ListLongOctetString::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.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 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[NSData class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (NSData *) value[i_0];
                        listHolder_0->mList[i_0] = [self asByteSpan:element_0];
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeListLongOctetStringWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ListLongOctetString::TypeInfo;
            auto successFn = Callback<TestClusterListLongOctetStringListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeListLongOctetStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterListLongOctetStringListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TestCluster::Attributes::ListLongOctetString::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TestClusterListLongOctetStringListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeListFabricScopedWithParams:(MTRReadParams * _Nullable)params
                                     completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{ // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterListFabricScopedListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::ListFabricScoped::TypeInfo;
            auto successFn = Callback<TestClusterListFabricScopedListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(
                successFn->mContext, successFn->mCall, failureFn->mCall, params.fabricFiltered);
        });
}

- (void)writeAttributeListFabricScopedWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeListFabricScopedWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeListFabricScopedWithValue:(NSArray * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                                     completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::ListFabricScoped::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.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 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[MTRTestClusterClusterTestFabricScoped class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (MTRTestClusterClusterTestFabricScoped *) value[i_0];
                        listHolder_0->mList[i_0].fabricSensitiveInt8u = element_0.fabricSensitiveInt8u.unsignedCharValue;
                        if (element_0.optionalFabricSensitiveInt8u != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].optionalFabricSensitiveInt8u.Emplace();
                            definedValue_2 = element_0.optionalFabricSensitiveInt8u.unsignedCharValue;
                        }
                        if (element_0.nullableFabricSensitiveInt8u == nil) {
                            listHolder_0->mList[i_0].nullableFabricSensitiveInt8u.SetNull();
                        } else {
                            auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableFabricSensitiveInt8u.SetNonNull();
                            nonNullValue_2 = element_0.nullableFabricSensitiveInt8u.unsignedCharValue;
                        }
                        if (element_0.nullableOptionalFabricSensitiveInt8u != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalFabricSensitiveInt8u.Emplace();
                            if (element_0.nullableOptionalFabricSensitiveInt8u == nil) {
                                definedValue_2.SetNull();
                            } else {
                                auto & nonNullValue_3 = definedValue_2.SetNonNull();
                                nonNullValue_3 = element_0.nullableOptionalFabricSensitiveInt8u.unsignedCharValue;
                            }
                        }
                        listHolder_0->mList[i_0].fabricSensitiveCharString = [self asCharSpan:element_0.fabricSensitiveCharString];
                        listHolder_0->mList[i_0].fabricSensitiveStruct.a = element_0.fabricSensitiveStruct.a.unsignedCharValue;
                        listHolder_0->mList[i_0].fabricSensitiveStruct.b = element_0.fabricSensitiveStruct.b.boolValue;
                        listHolder_0->mList[i_0].fabricSensitiveStruct.c
                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].fabricSensitiveStruct.c)>>(
                                element_0.fabricSensitiveStruct.c.unsignedCharValue);
                        listHolder_0->mList[i_0].fabricSensitiveStruct.d = [self asByteSpan:element_0.fabricSensitiveStruct.d];
                        listHolder_0->mList[i_0].fabricSensitiveStruct.e = [self asCharSpan:element_0.fabricSensitiveStruct.e];
                        listHolder_0->mList[i_0].fabricSensitiveStruct.f
                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].fabricSensitiveStruct.f)>>(
                                element_0.fabricSensitiveStruct.f.unsignedCharValue);
                        listHolder_0->mList[i_0].fabricSensitiveStruct.g = element_0.fabricSensitiveStruct.g.floatValue;
                        listHolder_0->mList[i_0].fabricSensitiveStruct.h = element_0.fabricSensitiveStruct.h.doubleValue;
                        {
                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].fabricSensitiveInt8uList)>;
                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
                            if (element_0.fabricSensitiveInt8uList.count != 0) {
                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.fabricSensitiveInt8uList.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.fabricSensitiveInt8uList.count; ++i_2) {
                                    if (![element_0.fabricSensitiveInt8uList[i_2] isKindOfClass:[NSNumber class]]) {
                                        // Wrong kind of value.
                                        return CHIP_ERROR_INVALID_ARGUMENT;
                                    }
                                    auto element_2 = (NSNumber *) element_0.fabricSensitiveInt8uList[i_2];
                                    listHolder_2->mList[i_2] = element_2.unsignedCharValue;
                                }
                                listHolder_0->mList[i_0].fabricSensitiveInt8uList
                                    = ListType_2(listHolder_2->mList, element_0.fabricSensitiveInt8uList.count);
                            } else {
                                listHolder_0->mList[i_0].fabricSensitiveInt8uList = ListType_2();
                            }
                        }
                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeListFabricScopedWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ListFabricScoped::TypeInfo;
            auto successFn = Callback<TestClusterListFabricScopedListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeListFabricScopedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterListFabricScopedListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::ListFabricScoped::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterListFabricScopedListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTimedWriteBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::TimedWriteBoolean::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTimedWriteBooleanWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeTimedWriteBooleanWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeTimedWriteBooleanWithValue:(NSNumber * _Nonnull)value
                                          params:(MTRWriteParams * _Nullable)params
                                      completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::TimedWriteBoolean::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeTimedWriteBooleanWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::TimedWriteBoolean::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeTimedWriteBooleanWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::TimedWriteBoolean::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneralErrorBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::GeneralErrorBoolean::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneralErrorBooleanWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeGeneralErrorBooleanWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeGeneralErrorBooleanWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::GeneralErrorBoolean::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeGeneralErrorBooleanWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::GeneralErrorBoolean::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneralErrorBooleanWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::GeneralErrorBoolean::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterErrorBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::ClusterErrorBoolean::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterErrorBooleanWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeClusterErrorBooleanWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeClusterErrorBooleanWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::ClusterErrorBoolean::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeClusterErrorBooleanWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ClusterErrorBoolean::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterErrorBooleanWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::ClusterErrorBoolean::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUnsupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUnsupportedWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeUnsupportedWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeUnsupportedWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeUnsupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo;
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeUnsupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo;
            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableBooleanWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableBooleanWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableBooleanWithValue:(NSNumber * _Nullable)value
                                        params:(MTRWriteParams * _Nullable)params
                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.boolValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableBooleanWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo;
            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableBooleanWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableBitmap8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterNullableBitmap8AttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo;
            auto successFn = Callback<TestClusterNullableBitmap8AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableBitmap8WithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableBitmap8WithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableBitmap8WithValue:(NSNumber * _Nullable)value
                                        params:(MTRWriteParams * _Nullable)params
                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableBitmap8WithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo;
            auto successFn = Callback<TestClusterNullableBitmap8AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableBitmap8WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterNullableBitmap8AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterNullableBitmap8AttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableBitmap16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterNullableBitmap16AttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo;
            auto successFn = Callback<TestClusterNullableBitmap16AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableBitmap16WithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableBitmap16WithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableBitmap16WithValue:(NSNumber * _Nullable)value
                                         params:(MTRWriteParams * _Nullable)params
                                     completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedShortValue);
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableBitmap16WithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo;
            auto successFn = Callback<TestClusterNullableBitmap16AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableBitmap16WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterNullableBitmap16AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterNullableBitmap16AttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableBitmap32WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterNullableBitmap32AttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo;
            auto successFn = Callback<TestClusterNullableBitmap32AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableBitmap32WithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableBitmap32WithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableBitmap32WithValue:(NSNumber * _Nullable)value
                                         params:(MTRWriteParams * _Nullable)params
                                     completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedIntValue);
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableBitmap32WithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo;
            auto successFn = Callback<TestClusterNullableBitmap32AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableBitmap32WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterNullableBitmap32AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterNullableBitmap32AttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableBitmap64WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterNullableBitmap64AttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo;
            auto successFn = Callback<TestClusterNullableBitmap64AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableBitmap64WithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableBitmap64WithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableBitmap64WithValue:(NSNumber * _Nullable)value
                                         params:(MTRWriteParams * _Nullable)params
                                     completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedLongLongValue);
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableBitmap64WithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo;
            auto successFn = Callback<TestClusterNullableBitmap64AttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableBitmap64WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterNullableBitmap64AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterNullableBitmap64AttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt8uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt8uWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt8uWithValue:(NSNumber * _Nullable)value
                                      params:(MTRWriteParams * _Nullable)params
                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt8uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt16uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt16uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt16uWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt16uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt16uWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt16uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt24uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt24uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt24uWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt24uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedIntValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt24uWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt24uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt32uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt32uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt32uWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt32uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedIntValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt32uWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo;
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt32uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt40uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt40uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt40uWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt40uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedLongLongValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt40uWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt40uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt48uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt48uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt48uWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt48uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedLongLongValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt48uWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt48uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt56uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt56uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt56uWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt56uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedLongLongValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt56uWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt56uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt64uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt64uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt64uWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt64uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedLongLongValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt64uWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo;
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt64uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt8sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo;
            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt8sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt8sWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt8sWithValue:(NSNumber * _Nullable)value
                                      params:(MTRWriteParams * _Nullable)params
                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.charValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt8sWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo;
            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt8sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt16sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt16sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt16sWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt16sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt16sWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt16sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt24sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo;
            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt24sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt24sWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt24sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.intValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt24sWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo;
            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt24sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt32sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo;
            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt32sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt32sWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt32sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.intValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt32sWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo;
            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt32sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt40sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo;
            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt40sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt40sWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt40sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.longLongValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt40sWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo;
            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt40sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt48sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo;
            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt48sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt48sWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt48sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.longLongValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt48sWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo;
            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt48sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt56sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo;
            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt56sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt56sWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt56sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.longLongValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt56sWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo;
            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt56sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt64sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo;
            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableInt64sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableInt64sWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableInt64sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.longLongValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableInt64sWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo;
            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableInt64sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableEnum8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableEnum8WithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableEnum8WithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableEnum8WithValue:(NSNumber * _Nullable)value
                                      params:(MTRWriteParams * _Nullable)params
                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableEnum8WithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableEnum8WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableEnum16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableEnum16WithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableEnum16WithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableEnum16WithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableEnum16WithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableEnum16WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableFloatSingleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableFloatAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo;
            auto successFn = Callback<NullableFloatAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableFloatSingleWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableFloatSingleWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableFloatSingleWithValue:(NSNumber * _Nullable)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.floatValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableFloatSingleWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableFloatAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo;
            auto successFn = Callback<NullableFloatAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableFloatSingleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableFloatAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableFloatAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableFloatDoubleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableDoubleAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo;
            auto successFn = Callback<NullableDoubleAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableFloatDoubleWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableFloatDoubleWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableFloatDoubleWithValue:(NSNumber * _Nullable)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.doubleValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableFloatDoubleWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableDoubleAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo;
            auto successFn = Callback<NullableDoubleAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableDoubleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableFloatDoubleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableDoubleAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableDoubleAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableOctetStringWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo;
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableOctetStringWithValue:(NSData * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableOctetStringWithValue:(NSData * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableOctetStringWithValue:(NSData * _Nullable)value
                                            params:(MTRWriteParams * _Nullable)params
                                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = [self asByteSpan:value];
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableOctetStringWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo;
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableOctetStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableCharStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo;
            auto successFn = Callback<NullableCharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableCharStringWithValue:(NSString * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableCharStringWithValue:(NSString * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableCharStringWithValue:(NSString * _Nullable)value
                                           params:(MTRWriteParams * _Nullable)params
                                       completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = [self asCharSpan:value];
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableCharStringWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:
                                             (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo;
            auto successFn = Callback<NullableCharStringAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableCharStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableCharStringAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableEnumAttrWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableEnumAttr::TypeInfo;
            auto successFn = Callback<NullableTestClusterClusterSimpleEnumAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableEnumAttrWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableEnumAttrWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableEnumAttrWithValue:(NSNumber * _Nullable)value
                                         params:(MTRWriteParams * _Nullable)params
                                     completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableEnumAttr::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableEnumAttrWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableEnumAttr::TypeInfo;
            auto successFn = Callback<NullableTestClusterClusterSimpleEnumAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableEnumAttrWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TestCluster::Attributes::NullableEnumAttr::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<NullableTestClusterClusterSimpleEnumAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeNullableStructWithCompletion:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                      NSError * _Nullable error))completion
{
    new MTRTestClusterNullableStructStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableStruct::TypeInfo;
            auto successFn = Callback<TestClusterNullableStructStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableStructWithValue:(MTRTestClusterClusterSimpleStruct * _Nullable)value
                                   completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableStructWithValue:(MTRTestClusterClusterSimpleStruct * _Nullable) value
                                         params:nil
                                     completion:completion];
}
- (void)writeAttributeNullableStructWithValue:(MTRTestClusterClusterSimpleStruct * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableStruct::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0.a = value.a.unsignedCharValue;
                nonNullValue_0.b = value.b.boolValue;
                nonNullValue_0.c = static_cast<std::remove_reference_t<decltype(nonNullValue_0.c)>>(value.c.unsignedCharValue);
                nonNullValue_0.d = [self asByteSpan:value.d];
                nonNullValue_0.e = [self asCharSpan:value.e];
                nonNullValue_0.f = static_cast<std::remove_reference_t<decltype(nonNullValue_0.f)>>(value.f.unsignedCharValue);
                nonNullValue_0.g = value.g.floatValue;
                nonNullValue_0.h = value.h.doubleValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableStructWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                       NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableStruct::TypeInfo;
            auto successFn = Callback<TestClusterNullableStructStructAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableStructWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                             NSError * _Nullable error))completion
{
    new MTRTestClusterNullableStructStructAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableStruct::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterNullableStructStructAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableRangeRestrictedInt8uWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableRangeRestrictedInt8uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableRangeRestrictedInt8uWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableRangeRestrictedInt8uWithValue:(NSNumber * _Nullable)value
                                                     params:(MTRWriteParams * _Nullable)params
                                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableRangeRestrictedInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableRangeRestrictedInt8uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableRangeRestrictedInt8sWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    new MTRNullableInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableRangeRestrictedInt8sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableRangeRestrictedInt8sWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableRangeRestrictedInt8sWithValue:(NSNumber * _Nullable)value
                                                     params:(MTRWriteParams * _Nullable)params
                                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.charValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableRangeRestrictedInt8sWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableRangeRestrictedInt8sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    new MTRNullableInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableRangeRestrictedInt16uWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableRangeRestrictedInt16uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableRangeRestrictedInt16uWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableRangeRestrictedInt16uWithValue:(NSNumber * _Nullable)value
                                                      params:(MTRWriteParams * _Nullable)params
                                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableRangeRestrictedInt16uWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableRangeRestrictedInt16uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableRangeRestrictedInt16sWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNullableRangeRestrictedInt16sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableRangeRestrictedInt16sWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableRangeRestrictedInt16sWithValue:(NSNumber * _Nullable)value
                                                      params:(MTRWriteParams * _Nullable)params
                                                  completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeNullableRangeRestrictedInt16sWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeNullableRangeRestrictedInt16sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWriteOnlyInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::WriteOnlyInt8u::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWriteOnlyInt8uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeWriteOnlyInt8uWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeWriteOnlyInt8uWithValue:(NSNumber * _Nonnull)value
                                       params:(MTRWriteParams * _Nullable)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    value = [value copy];

    new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue, self.device,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            chip::Optional<uint16_t> timedWriteTimeout;
            if (params != nil) {
                if (params.timedWriteTimeout != nil) {
                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
                }
            }

            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::WriteOnlyInt8u::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(
                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
        });
}

- (void)subscribeAttributeWriteOnlyInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::WriteOnlyInt8u::TypeInfo;
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeWriteOnlyInt8uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::WriteOnlyInt8u::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<TestClusterGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::GeneratedCommandList::TypeInfo;
            auto successFn = Callback<TestClusterGeneratedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TestCluster::Attributes::GeneratedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TestClusterGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<TestClusterAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::AcceptedCommandList::TypeInfo;
            auto successFn = Callback<TestClusterAcceptedCommandListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(
        queue, completion, ^(Cancelable * success, Cancelable * failure) {
            if (clusterStateCacheContainer.cppClusterStateCache) {
                chip::app::ConcreteAttributePath path;
                using TypeInfo = TestCluster::Attributes::AcceptedCommandList::TypeInfo;
                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
                path.mClusterId = TypeInfo::GetClusterId();
                path.mAttributeId = TypeInfo::GetAttributeId();
                TypeInfo::DecodableType value;
                CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
                auto successFn = Callback<TestClusterAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                if (err == CHIP_NO_ERROR) {
                    successFn->mCall(successFn->mContext, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<TestClusterAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::AttributeList::TypeInfo;
            auto successFn = Callback<TestClusterAttributeListListAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.fabricFiltered, params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    new MTRTestClusterAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::AttributeList::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<TestClusterAttributeListListAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::FeatureMap::TypeInfo;
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::FeatureMap::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            using TypeInfo = TestCluster::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    // Make a copy of params before we go async.
    params = [params copy];
    new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, self.device, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
            if (!params.autoResubscribe) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ClusterRevision::TypeInfo;
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.fabricFiltered,
                params.keepPreviousSubscriptions);
        },
        subscriptionEstablished);
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
        if (clusterStateCacheContainer.cppClusterStateCache) {
            chip::app::ConcreteAttributePath path;
            using TypeInfo = TestCluster::Attributes::ClusterRevision::TypeInfo;
            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
            path.mClusterId = TypeInfo::GetClusterId();
            path.mAttributeId = TypeInfo::GetAttributeId();
            TypeInfo::DecodableType value;
            CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get<TypeInfo>(path, value);
            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
            if (err == CHIP_NO_ERROR) {
                successFn->mCall(successFn->mContext, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

// NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)